在容器类中将虚拟对象与shared_ptr / unique_ptr一起使用

Question

我对C ++相当陌生（来自Java / PHP）。 基本上，我需要创建一个容器类，其中将包含对虚拟类实例（基类）的唯一/共享指针的引用。 我无法编译这段代码（我正在使用MSVC 2015）。

编译器错误是：

error C2280: 'std::unique_ptr<Base,std::default_delete<_Ty>>::unique_ptr(const std::unique_ptr<_Ty,std::default_delete<_Ty>> &)': attempting to reference a deleted function

这是重现此问题的示例应用程序：

#include <iostream>
#include <memory>

class Base {
    public:
        virtual void foo() const = 0;
        virtual void bar() const = 0;
};

class Derived : public Base {
    public:
        void foo() const override {
            std::cout << "foo" << std::endl;

        };

        void bar() const override{
            std::cout << "bar" << std::endl;
        };
};

class ContainerUnique {
    public:
        ContainerUnique() {
            ptr = nullptr;
        }

        void assignPtr(const Base &instance) {
            auto ptr = std::make_unique<Base>(instance);
            ptr.swap(ptr);
        };

        std::unique_ptr<Base> getPtr() {
            return ptr;
        };

    private:
        std::unique_ptr<Base> ptr;
};

class ContainerShared {
    public:
        ContainerShared() {
            ptr = nullptr;
        }

        void assignPtr(const Base &instance) {
            auto ptr = std::make_shared<Base>(instance);
            ptr.swap(ptr);
        };

        std::shared_ptr<Base> getPtr() {
            return ptr;
        };

    private:
        std::shared_ptr<Base> ptr;
};

int main() {
    Derived derived1 = Derived();
    Derived derived2 = Derived();

    ContainerUnique cu = ContainerUnique();
    ContainerShared cs = ContainerShared();

    cu.assignPtr(derived1);
    cs.assignPtr(derived2);

    std::unique_ptr<Base> uptr = cu.getPtr();
    std::shared_ptr<Base> sptr = cs.getPtr();

    return 0;
}

请指教

Answer 1

您应该考虑对象所有权以及对象的生存位置（堆栈或堆），您可能不需要在Java中都关注它们。

因为ContainerUnique有一个unique_ptr成员，所以我推断它打算拥有指向的对象。 它有义务删除它。 这与其余部分不一致，因为derived1在堆栈中，因此不需要任何东西拥有，也无法删除。 相反，假设我们在堆上创建了derived1 ：

auto derived1 = std::make_unique<Derived>();

这会在堆上创建它，因此需要进行管理，并通过将其指针存储在unique_ptr来将我们标识为拥有该对象。 要使用unique_ptr转移所有权，我们必须调整接口：

// Interface
void ContainerUnique::assignPtr(std::unique_ptr<Base> instance);
// Call site
cu.assignPtr(std::move(derived1));

如果我们使用原始引用或指针，则界面或调用站点中没有任何内容可以反映所有权的预期更改。 如果我们引用Base，并调用std::make_unique我们正在复制，并正在复制Base（丢失任何派生数据）。 采用unique_ptr可能是传达所有权转让的最清晰方法。

把它放在一起：

#include <memory>

struct Base {
    virtual void foo() const = 0;
    virtual void bar() const = 0;
};

struct Derived : Base {
    void foo() const override { }
    void bar() const override { }
};

class ContainerUnique {
    public:
        void assignPtr(std::unique_ptr<Base> instance) {
            ptr.swap(instance);
        };

        std::unique_ptr<Base> getPtr() {
            return std::move(ptr);
        };

    private:
        std::unique_ptr<Base> ptr;
};

int main() {
    auto derived1 = std::make_unique<Derived>();
    auto cu = ContainerUnique();
    cu.assignPtr(std::move(derived1));
    auto uptr = cu.getPtr();
}