std::move 不创建派生类

Question

我有一个容器，其中包含std::vector<std::shared_ptr<Base> > vec 中基类Base 的shared_ptr，这个容器也有函数add(Base&& base) - 它通过使用std::move 运算符将基对象添加到vec，但派生的移动构造函数不调用，仅调用了基本移动构造函数。

如何解决：我应该使用 dynamic_cast<Derived*>(&base) 将其转换为 Derived，然后使用 std::move。

问题：我是否需要尝试强制转换为所有可能的派生类，然后使用std::move？

class Base{
public:
    virtual ~Base(){}

    Base(const Base& base) = delete;
    Base(Base&& base){
        std::cout<<"base move\n";
    }
    Base(){}

    virtual void func(){
        std::cout<<"run func from BASE class\n";
    }
};
class Derived: public Base{
public:
    virtual ~Derived() = default;
    Derived(Derived&& derived):Base(std::move(derived)){
        std::cout<<"Derived move\n";
    }
    Derived():Base(){

    }

    virtual void func() override {
        std::cout<<"run func from DERIVED class\n";
    }
};
class Container{
    std::vector<shared_ptr<Base> > vec;
public:
    void add(Base&& base){
        this->vec.push_back(std::make_shared<Base>(std::move(base)));
    }
    void addDerived(Base&& base){
        //TRY ALL POSSIBLE CASTING???
        this->vec.push_back(std::make_shared<Derived>(std::move( *(dynamic_cast<Derived*>(&base)) )));
    }

    void print(){
        for(auto& obj: vec){
            obj->func();
        }
    }
};
int main() {
    std::cout << "Create container and add using function `add`" << std::endl;
    Container container;
    container.add(Derived());
    container.print();

    std::cout << "Create container and add using function `addDerived`" << std::endl;
    Container container_new;
    container_new.addDerived(Derived());
    container_new.print();
}
//Will print
Create container and add using function `add`
base move
run func from BASE class
Create container and add using function `addDerived`
base move
Derived move
run func from DERIVED class

Answer 1

这是一个糟糕的界面：

void add(Base&& base){
    this->vec.push_back(std::make_shared<Base>(std::move(base)));
}

您总是在创建一个Base。您正在切掉基础子对象，这不是真正的多态副本。为此，您必须在Base 上添加类似clone() 的方法。

但是将多态性留给用户更简单。你的工作只是提供一个安全的界面。该界面应该是：

void add(std::shared_ptr<Base> p) {
    vec.push_back(std::move(p));
}

现在，作为用户，我可以为我想要的任何派生类型提供shared_ptr，而无需您作为界面设计师担心：

container.add(std::make_shared<MySuperCoolDerived>(42)); // cool

Answer 2

template<class D>
std::enable_if_t< std::is_convertible<std::decay_t<D>*, Base*>::value >
add(D&& d){
  add(std::make_shared<std::decay_t<D>>(std::forward<D>(d)));
}
void add(std::shared_ptr<Base> base){
  this->vec.push_back(std::move(base));
}
template<class D, class...Args>
void emplace(Args&&...args){
  add(std::make_shared<D>(std::forward<Args>(args)...));
}

现在有 3 种添加方式。

add(Derives()) 按您的意愿工作。 add(std::make_shared<Foo>(7)) 可以让你直接注入共享的ptrs。

而emplace<Derived>(args...) 让您可以就地构建它。

插件有一个花哨的 SFINAE 检查；我跳过了它的位置。你可以做同样的可转换检查，如果 D 来自 Args，则 add 是可构造的......另外，当我编写 emplace 时，我有时会添加第一个参数是初始化列表构造函数，因为它修复了完美转发的常见缺陷。

Answer 3

您需要停止尝试移动到开始的对象中。如果您想要一个指向某个基类的指针容器，但您不希望用户直接分配您存储的派生类，那么应该由您的插入函数来进行分配。在这种情况下，它应该像典型的标准库 emplace 函数一样工作：

template<typename T, typename ...Args>
void add(Args && ...args)
{
    static_assert(std::is_base_of<Base, T>::value, "The type must be a base class of `Base`");
    static_assert(std::is_convertible<T&, Base&>::value, "The type must be an *accessible* base class of `Base`");
    this->vec.push_back(std::make_shared<T>(std::forward<Args>(args)...));
}

...

container.add<Derived>();

如果用户有一个Derived 实例，他们想要移动到由container 创建的新Derived，那么他们会执行container.add<Derived>(std::move(theirDerivedInstance));。