How to Properly Copy C 11 Classes Containing `unique_ptr` Members?

Copying Classes with Unique Pointers in C 11

Creating a copy constructor for a class containing a unique_ptr, a smart pointer that enforces exclusive ownership, poses unique challenges. In C 11, managing unique_ptr members requires careful consideration.

Solution:

To implement a copy constructor, you have two options:

1. Deep Copy: Create a new copy of the unique_ptr's content. This ensures both objects own their data independently.

class A {
  std::unique_ptr<int> up_;
public:
  A(int i) : up_(new int(i)) {}
  A(const A& a) : up_(new int(*a.up_)) {}
};

2. Convert to shared_ptr: Convert the unique_ptr to a shared_ptr, which allows multiple owners.

std::shared_ptr<int> sp = std::make_shared<int>(*up_);

Additional Considerations:

• Move Constructor: Instead of a copy constructor, you could use a move constructor, which transfers ownership of the unique_ptr.

A(A&& a) : up_(std::move(a.up_)) {}

• Overloading Other Operators: For a complete set of operations, it's helpful to overload the assignment operators.

A& operator=(const A& a) { up_.reset(new int(*a.up_)); return *this; }
A& operator=(A&& a) { up_ = std::move(a.up_); return *this; }

• Vector Considerations: If you intend to use your class in a std::vector, decide if the vector will exclusively own the objects. You can enforce move-only behavior by omitting the copy constructor and copy assignment operators.

The above is the detailed content of How to Properly Copy C 11 Classes Containing `unique_ptr` Members?. For more information, please follow other related articles on the PHP Chinese website!