如何在一些智能指针中实现深拷贝功能？答案

【问题标题】：How to implement deep copy feature in some smart pointer?如何在一些智能指针中实现深拷贝功能？
【发布时间】：2015-01-22 07:10:42
【问题描述】：

unique_ptr 非常有用。但是，它是不可复制的。如果为其指向的类提供虚拟克隆（深拷贝）方法，我认为它会变得更加有用。是否有必要或更好的方法来实现它？某些库中是否存在类似的智能指针？这是一个版本

template<class T>
class deep_ptr: private unique_ptr<T>
{
public:
    using unique_ptr<T>::operator *;
    using unique_ptr<T>::operator ->;
    using unique_ptr<T>::operator bool;
    using unique_ptr<T>::release;
    using unique_ptr<T>::reset;
    using unique_ptr<T>::get;

    // add (DEFAULT_CONSTRUCTOR)(MOVE_CONSTRUCTOR)(MOVE_ASSIGNMENT_METHOD) ...

    explicit deep_ptr(T* p) : unique_ptr(p) {}

    deep_ptr(deep_ptr const& r) : unique_ptr(r->clone()) {}

    deep_ptr& operator=(deep_ptrconst& r)
    { if (this != &r) reset(r->clone()); return *this; }
};

只是觉得它很有用，但从未见过类似的东西。？？？

【问题讨论】：

你能贴几行代码来说明你打算如何使用它吗？
@GuyGreer 哦，我的错，我误解了这个问题。
@GuyGreer - shared_ptr 没有深拷贝和浅拷贝语义。这取决于它指向的对象
@EdHeal 我的意思是复制一个 shared_ptr 不会复制底层对象，这使它成为一个浅拷贝，除非我误解了什么。
"... 但是，它不可复制" - 使其可复制会造成两个 unique_ptr 管理同一个对象的情况。这将打破unique_ptr 的单一所有权语义。

标签： c++ smart-pointers

【解决方案1】：

除非我误解了您要查找的内容，否则如果一个类具有克隆方法，则应该足以获得您要查找的内容。

示例代码：

#include <iostream>
#include <memory>

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

struct B : A
{
   B(int in = 0) : x(in) {}
   B(B const& copy) : x(copy.x) {}
   virtual ~B() {std::cout << "In B::~B()\n";}

   virtual A* clone() { return new B(*this); }
   int x;
};

int main()
{
   std::unique_ptr<A> p1(new B(10));
   std::unique_ptr<A> p2(p1->clone());
   return 0;
}

运行上述程序的输出：

在 B::~B() 在 B::~B()

【讨论】：

如果指针是可深度复制的类的成员。我不能使用隐式复制构造函数。
@user1899020，你的意思是“如果std::unique_ptr是一个类的成员......”？？
像 A 类 { unique_ptr mB; ... } 为了使 A 可复制，我们需要编写一个复制构造函数。如果使用 deep_ptr，我们可以使用编译器提供的版本。
@user1899020，除非你有很多这样的类，否则最好为A编写一个复制构造函数而不是从std::unique_ptr派生。

【解决方案2】：

如果没有克隆方法（只是一个复制构造函数），以下应该可以工作：

template <typename T>
class deep_ptr
{
public:
  deep_ptr() : i_() {}

  deep_ptr(std::nullptr_t) : i_(nullptr) {}

  template <typename U>
    deep_ptr(U* u) : i_(u ? new inner_impl<U>(*u) : nullptr) {}

  ~deep_ptr() { delete i_; }

  deep_ptr(const deep_ptr& p) : i_(p.i_ ? p.i_->copy() : nullptr) {}

  deep_ptr& operator=(const deep_ptr& p)
  {
    if (!p.i_) { i_ = nullptr; }
    else { i_ = p.i_->copy(); }
  }

  deep_ptr(deep_ptr&& p) : i_(p.i_) { p.i_ = nullptr; }

  deep_ptr& operator=(deep_ptr&& p)
  {
    i_ = p.i_;
    p.i_ = nullptr;
  }

  const T* operator->() const { return get(); }

  const T* get() const
  {
    if (i_) { return *i_; }
    return nullptr;
  }

  const T& operator*() const { return *static_cast<T*>(*i_); }

  T* operator->() { return get(); }

  T* get()
  {
    if (i_) { return *i_; }
    return nullptr;
  }

  T& operator*(){ return *static_cast<T*>(*i_); }

private:
  struct inner
  { 
    virtual inner* copy() const = 0;
    virtual operator const T*() const  = 0;
    virtual operator T*() = 0;
    virtual ~inner() {}
  };

  inner* i_;

  template <typename U>
  struct inner_impl : inner
  {
    inner_impl(const U& u) : u_(u) {}
    inner_impl* copy() const override { return new inner_impl(u_); }
    operator const T*() const override { return &u_; }
    operator T*() override { return &u_; }

    U u_;
  };
};

【讨论】：