Question

我有一个指向基类 foo 的指针向量，它有几个子类，我想要做的是基于它是哪个子类，创建一个新的类同样的例子。

我之前通过一个巨大的for循环解决了它，它使用typeid找出它是什么类但是没有办法以更一般的方式解决它？

基本上，我正在寻找这样的东西：

std::vector<foo*> a;
std::vector<foo*> b;

//Store a couple of classes in a and b

b[0] = new typeid(a[0]).name();

Answer 1

一种方法是使用虚拟clone()方法返回指向正确类型对象的指针：

struct base 
{
  virtual base* clone()=0;
  virtual ~base() {}
};

struct foo : public base
{
  virtual base* clone() { return new foo(*this); }
};

struct bar : public base
{
  virtual base* clone() { return new bar(*this); }
};

然后你的代码将是

b[0] = a[0].clone();

在现实代码中，您将返回一个智能指针，例如std::unique_ptr<base>。

Answer 2

每当你有一个基于类型的巨型开关时，你应该使用虚拟功能。

您应该介绍某种虚拟clone()功能：

#include <iostream>
#include <memory>

struct base
{
    virtual ~base() {};

    virtual void do_stuff() = 0;

    // cloning interface
    std::unique_ptr<base> clone() const
    {
        return std::unique_ptr<base>(do_clone());
    }

private:
    // actual clone implementation; uses a raw pointer to support covariance
    virtual base* do_clone() const = 0;
};

struct derived_A : base
{
    void do_stuff() override { std::cout << "stuff in derived_A" << std::endl; }

    // purposefully hide the base implementation,
    // since we know we'll be returning a derived_A
    std::unique_ptr<derived_A> clone() const
    {
        return std::unique_ptr<derived_A>(do_clone());
    }

private:
    derived_A* do_clone() const override
    {
        return new derived_A(*this);
    }
};

struct derived_B : base
{
    void do_stuff() override { std::cout << "stuff in derived_B" << std::endl; }

    // purposefully hide the base implementation,
    // since we know we'll be returning a derived_B
    std::unique_ptr<derived_B> clone() const
    {
        return std::unique_ptr<derived_B>(do_clone());
    }

private:
    derived_B* do_clone() const override
    {
        return new derived_B(*this);
    }
};

#include <vector>

int main()
{
    std::vector<std::unique_ptr<base>> v1;
    std::vector<std::unique_ptr<base>> v2;

    std::unique_ptr<base> x(new derived_A);
    v1.push_back(std::move(x));

    std::unique_ptr<base> y(new derived_B);
    v1.push_back(std::move(y));

    v1[0]->do_stuff();
    v1[1]->do_stuff();

    // clone
    v2.push_back(v1[0]->clone());
    v2.push_back(v1[1]->clone());

    v2[0]->do_stuff();
    v2[1]->do_stuff();
}

我们希望返回类型的协方差（如果你持有指向静态类型derived_A的指针，克隆它应该产生derived_A以避免冗余强制转换），这就是克隆接口是分成两部分。如果std::unique_ptr<base>与std::unique_ptr<derived>协变，则可以在一个中完成，但这只是原始指针的情况。

我确信有一种方法可以隐藏重复的样板，这对读者来说是一种练习。

编辑：其实，你走了;不太难：

#include <memory>

// Note: leaves with a public: access specifier
#define DEFINE_ABSTRACT_CLONEABLE(selfType)         \
        DEFINE_CLONEABLE_DETAIL(selfType)           \
        private:                                    \
            virtual selfType* do_clone() const = 0; \
                                                    \
        public:

// Note: leaves with a public: access specifier
#define DEFINE_CLONEABLE(selfType)              \
        DEFINE_CLONEABLE_DETAIL(selfType)       \
        private:                                \
            selfType* do_clone() const override \
            {                                   \
                return new selfType(*this);     \
            }                                   \
                                                \
        public:

#define DEFINE_CLONEABLE_DETAIL(selfType)                                   \
        public:                                                             \
            std::unique_ptr<selfType> clone() const                         \
            {                                                               \
                static_assert(std::is_same<selfType,                        \
                                          std::decay<decltype(*this)>::type \
                                          >::value,                         \
                             "Must specify current class name.");           \
                                                                            \
                return std::unique_ptr<selfType>(do_clone());               \
            }                                                               \

测试（注意较小的尺寸）：

#include <iostream>

#include "cloneable.hpp" // or whatever 

struct base
{
    // readable error: DEFINE_ABSTRACT_CLONEABLE(int);
    DEFINE_ABSTRACT_CLONEABLE(base);

    virtual ~base() {};

    virtual void do_stuff() = 0;
};

struct derived_A : base
{
    DEFINE_CLONEABLE(derived_A);

    void do_stuff() override { std::cout << "stuff in derived_A" << std::endl; }
};

struct derived_B : base
{
    // error: DEFINE_CLONEABLE(derived_B);
    DEFINE_ABSTRACT_CLONEABLE(derived_B);

    void do_stuff() override { std::cout << "stuff in derived_B" << std::endl; }
    virtual void do_thing() = 0; // abstract again
};

struct derived_AA : derived_A
{
    DEFINE_CLONEABLE(derived_AA);

    void do_stuff() override { std::cout << "stuff in derived_AA" << std::endl; }
};

struct derived_BB : derived_B
{
    DEFINE_CLONEABLE(derived_BB);

    void do_stuff() override { std::cout << "doing stuff in derived_BB" << std::endl; }
    void do_thing() override { std::cout << "doing thing" << std::endl; }
};

int main()
{
    std::unique_ptr<derived_AA> x(new derived_AA());
    x->do_stuff();

    auto xx = x->clone();
    xx->do_stuff();

    std::unique_ptr<derived_A> xxx = xx->clone();
    xxx->do_stuff();

    std::unique_ptr<base> xxxx = xxx->clone();
    xxxx->do_stuff();

    xxxx->clone()->do_stuff();

    std::unique_ptr<derived_BB> y(new derived_BB());
    y->do_stuff();
    y->do_thing();

    auto yy = y->clone();
    yy->do_stuff();
    yy->do_thing();

    std::unique_ptr<derived_B> yyy = yy->clone();
    yyy->do_stuff();
    yyy->do_thing();

    std::unique_ptr<base> yyyy = yyy->clone();
    yyyy->do_stuff();
    // error, lost derived information: yyyy->do_thing(); 

    yyyy->clone()->do_stuff();
}

另一个改进是使do_clone纯虚拟的每个新声明强制进一步派生类来实现它，但这个留给读者。

Answer 3

使用dynamic_cast的方法稍微好一些。您可以尝试dynamic_cast然后调用相应的复制构造函数。话虽如此，我会选择clone解决方案，或尝试重新设计解决问题的方法。

例如，

child *c = dynamic_cast<child*>(base);
if(c != NULL) {
    return new child(c);
}

从现有的一次创建新的类实例？

3 个答案: