How can classes with `std::variant` members be copied safely?

Question

The following sample builds and runs properly with the line Container container2(container1); removed. It appears the copy constructor for std::variant itself is deleted, which makes my Container's copy constructor implicitly deleted.

Effectively, I'm asking:

1. What is the proper way to store a std::variant as a member?
2. What must be implemented in Container before safe copy/move assignment is allowed?

#include <string>
#include <variant>

class A {};

class Container {
 public:
  Container(int i) : data_(i) {}
  Container(float f) : data_(f) {}
  Container(std::string s) : data_(s) {}
  Container(std::unique_ptr<A> a) : data_(std::move(a)) {}
  std::variant<int, float, std::string, std::unique_ptr<A>> data_;
};

int main() {
  Container container1{3};
  
  // error: call to implicitly-deleted copy constructor of 'Container'
  // 
  // copy constructor of 'Container' is implicitly deleted because
  // field 'data_' has a deleted copy constructor
  Container container2(container1);

  return 0;
}

Answer 1

cppreference has this to say about std::variant's copy constructor:

Copy constructor. [...] This constructor is defined as deleted unless std::is_copy_constructible_v<T_i> is true for all T_i in Types. [...]

In other words, it is not deleted unless one or more of the types that the std::variant can contain is not copyable for whatever reason. In your case, it's the std::unique_ptr that's causing the problem. Perhaps std::shared_ptr would be more appropriate.

Answer 2

Yet another addition to what you've already gotten: You need to implement the copying yourself since no std::unique_ptr is copyable.

What must be implemented in Container before safe copy/move assignment is allowed?

For your specific case, where A is copy constructible and you'd like to support copying, it could look like this:

Container(const Container& rhs) {
    using namespace std; // to make the below less wide

    if(holds_alternative<int>(rhs.data_)) data_ = get<int>(rhs.data_);
    else if(holds_alternative<float>(rhs.data_)) data_ = get<float>(rhs.data_);
    else if(holds_alternative<string>(rhs.data_)) data_ = get<string>(rhs.data_);

    // this is the problematic one:

    else data_ = make_unique<A>( *get<unique_ptr<A>>(rhs.data_) );
}

std::get the pointer and dereference it (*) and let the copy constructor in A do its work.

There is no additional risk in doing this. Dereferencing the unique_ptr gets you an A& that you provide to make_unique which forwards that to the A being constructed. It's plain copying and there's no magic involved.

A slightly more complicated way could be to create your own unique_ptr wrapper that allows copying and use that in your variant instead.

Example:

template<typename T, typename D = std::default_delete<T>>
class copyable_obj_ptr {
public:
    template<typename... Args>
    copyable_obj_ptr(Args&&... args) : ptr(std::forward<Args>(args)...) {}
    
    // moving
    copyable_obj_ptr(copyable_obj_ptr&&) = default;
    copyable_obj_ptr& operator=(copyable_obj_ptr&&) = default;

    // copying
    copyable_obj_ptr(const copyable_obj_ptr& rhs) : ptr(new T(*rhs.ptr), D{}) {}
    copyable_obj_ptr& operator=(const copyable_obj_ptr& rhs) {
        ptr.reset(new T(*rhs.ptr));
        return *this;
    }

    // dereferencing
    T& operator*() { return *ptr; }
    const T& operator*() const { return *ptr; }

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

    // Add more proxy methods to access the unique_ptr's methods if you need them ...
private:
    std::unique_ptr<T, D> ptr;
};

Answer 3

Extending Paul Sanders' answer: what kind of copy do you want?

If it is a shallow copy, use shared_ptr<A>.

If it is a deep copy, why not have variant<..,A>? If the reason is that A is polymorphic, then the real problem is cloning each of the derived classes. You have to create your own mechanism for the cloning and your own copyable smart pointer to use it - as far as I know, there is nothing in the standard library to help you.