8

从boost 库文档中，我读到了这个：

从概念上讲，智能指针被视为拥有所指向的对象，因此在不再需要对象时负责将其删除。

我有一个非常简单的问题：我想将 RAII 用于可复制和可分配的类的指针属性。

复制和赋值操作应该很深：每个对象都应该有自己的实际数据副本。此外，RTTI 需要可用于属性（它们的类型也可以在运行时确定）。

我应该搜索 Copyable 智能指针的实现（数据很小，因此我不需要Copy on Write指针），还是将复制操作委托给我的对象的复制构造函数，如本答案所示？

对于可复制和可分配的类的简单 RAII，我应该选择哪个智能指针？（我认为将复制/赋值操作委托给类复制构造函数和赋值运算符的 unique_ptr 会做出正确的选择，但我不确定）

这是使用原始指针的问题的伪代码，它只是问题描述，而不是正在运行的 C++ 代码：

// Operation interface
class ModelOperation
{
    public: 
        virtual void operate = (); 
};

// Implementation of an operation called Special 
class SpecialModelOperation
:
    public ModelOperation
{
    private:
        // Private attributes are present here in a real implementation. 

    public: 

        // Implement operation
        void operate () {}; 
};

// All operations conform to ModelOperation interface
// These are possible operation names: 
// class MoreSpecialOperation; 
// class DifferentOperation; 

// Concrete model with different operations
class MyModel 
{
    private: 
        ModelOperation* firstOperation_; 
        ModelOperation* secondOperation_;  

    public:

        MyModel()
            : 
                firstOperation_(0), 
                secondOperation_(0)
        {
            // Forgetting about run-time type definition from input files here.
            firstOperation_  = new MoreSpecialOperation(); 
            secondOperation_ = new DifferentOperation(); 
        }

        void operate()
        {
            firstOperation_->operate(); 
            secondOperation_->operate();
        }

        ~MyModel() 
        {
            delete firstOperation_; 
            firstOperation_ = 0; 

            delete secondOperation_; 
            secondOperation_ = 0; 
        }
};

int main()
{

    MyModel modelOne; 

    // Some internal scope
    {
        // I want modelTwo to have its own set of copied, not referenced 
        // operations, and at the same time I need RAII to for the operations, 
        // deleting them automatically as soon as it goes out of scope. 
        // This saves me from writing destructors for different concrete models.  
        MyModel modelTwo (modelOne); 
    }


    return 0;
}
4

5 回答 5

6

如果您接受对您的类型的某些要求，则无需为所有类型实现虚拟克隆功能即可完成。特殊要求是这些类型具有可访问的复制构造函数，由于可能会意外切片，有些人会认为这是不可取的。不过，正确使用交友可能会减轻其缺点。

如果这是可以接受的，可以通过在提供复制功能的接口下擦除派生类型来解决此问题：

template <typename Base>
struct clonable {
    // virtual copy
    // this clone function will be generated via templates
    // no boilerplate is involved
    virtual std::unique_ptr<clonable<Base>> clone() const = 0;

    // expose the actual data
    virtual Base* get() = 0;
    virtual Base const* get() const = 0;

    // virtual destructor
    // note that this also obviates the need for a virtual destructor on Base
    // I would probably still make it virtual, though, just in case
    virtual ~clonable() = default;
};

该接口由以最派生类型为模板的类实现，因此知道如何通过复制构造函数进行正常复制。

template <typename Base, typename Derived>
struct clonable_holder : clonable<Base> {
    // I suppose other constructors could be provided
    // like a forwarding one for emplacing, but I am going for minimal here
    clonable_holder(Derived value)
    : storage(std::move(value)) {}

    // here we know the most derived type, so we can use the copy constructor
    // without risk of slicing
    std::unique_ptr<clonable<Base>> clone() const override {
        return std::unique_ptr<clonable<Base>>(new clonable_holder(storage));
    }

    Base* get() override { return &storage; }
    Base const* get() const override { return &storage; }

private:
    Derived storage;
};

这将为我们生成虚拟副本功能，而无需额外的样板。现在我们可以在此之上构建一个类似智能指针的类（不完全是智能指针，因为它不提供指针语义，而是提供值语义）。

template <typename Base>
struct polymorphic_value {
    // this constructor captures the most derived type and erases it
    // this is a point where slicing may still occur
    // so making it explicit may be desirable
    // we could force constructions through a forwarding factory class for extra safety
    template <typename Derived>
    polymorphic_value(Derived value)
    : handle(new clonable_holder<Base, Derived>(std::move(value))) {
        static_assert(std::is_base_of<Base, Derived>::value,
            "value must be derived from Base");
    }

    // moving is free thanks to unique_ptr
    polymorphic_value(polymorphic_value&&) = default;
    polymorphic_value& operator=(polymorphic_value&&) = default;

    // copying uses our virtual interface
    polymorphic_value(polymorphic_value const& that)
    : handle(that.handle->clone()) {}
    polymorphic_value& operator=(polymorphic_value const& that) {
        handle = that.handle->clone();
        return *this;
    }

    // other useful constructors involve upcasting and so on

    // and then useful stuff for actually using the value
    Base* operator->() { return handle.get(); }
    Base const* operator->() const { return handle.get(); }
    // ...

private:
    std::unique_ptr<clonable<Base>> handle;
};

这只是一个最小的界面，但可以从这里轻松充实以涵盖更多使用场景。

于 2012-12-17T12:12:02.800 回答
5

有点晚了，但对于未来的观众：在我的仅标头库Aurora及其SmartPtr 教程中有一个现成的实现。使用 Aurora，通过智能指针实现深度复制是微不足道的。以下代码适用于任何可复制类型T：

aurora::CopiedPtr<T> first(new T);
aurora::CopiedPtr<T> second = first; // deep copy

如果你的类有指针成员，这使得通常不需要实现三巨头/五巨头。

于 2016-01-10T13:56:09.007 回答
1

我从未听说过即用型实现，但您可以自己完成。

首先，您应该编写一些具有虚拟克隆方法的模板包装类，返回存储对象的副本。然后写一些可以复制的类的多态持有者

并且不要忘记检查删除 http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Checked_delete

于 2012-12-17T10:48:26.097 回答
1

听起来需要能够制作一个智能指针，每次创建另一个智能指针对象时都会创建一个对象的新副本。（我猜该副本是否“深”取决于对象的构造函数；据我们所知，您存储的对象可能具有许多深层次的所有权，因此“深”取决于对象。我们的主要目的是，当智能指针使用来自另一个对象的引用构造时，您想要创建一个不同对象的东西，而不是仅仅取出一个指向现有对象的指针。）

如果我正确理解了这个问题，那么您将需要一个虚拟克隆方法。没有其他方法可以正确调用派生类的构造函数。

struct Clonable {
  virtual ~Clonable() {}
  virtual Clonable* clone() = 0;
};
struct AutoPtrClonable {
  AutoPtrClonable(Clonable* cl=0) : obj(cl) { }
  AutoPtrClonable(const AutoPtrClonable& apc) : obj(apc.obj->clone()) { }
  ~AutoPtrClonable() { delete obj; }
  // operator->, operator*, etc
  Clonable* obj;
};

要使用示例代码，请将其制作为模板等。

于 2012-12-17T10:50:22.747 回答
0

你有两个解决方案（实际上你有更多，但这些对我来说最有意义:)）：

首先，您可以使用std::unique_ptr. 这是一个很好的解决方案，因为它强制您每个指针都有一个实例。（使用std::shared_ptr代替也可以，但如果您不明确添加代码，shared_ptr 的复制和分配将“共享” - 特别是您想要避免的）。

如果您使用std::unique_ptr，您的复制构造函数和赋值运算符应该显式地进行深度复制（使用clone指针接口中的虚拟方法，或调用unique_ptr构造函数中的 new 运算符）。

其次，您可以自己滚动。它没有什么复杂的，我们谈论的是一个小的（10-20 行左右）实用程序类。

就个人而言，如果我必须在一个地方使用这个智能指针类，我会使用 std::unique_ptr。否则（多个指针，相同的行为）我会自己滚动，这样我就不必为许多实例重复深度复制（以保持 DRY 原则）。

于 2012-12-17T12:01:14.523 回答