6

以下示例在Container container2(container1);删除该行的情况下正确构建和运行。似乎std::variant删除了自身的复制构造函数，这使得 myContainer的复制构造函数被隐式删除。

实际上，我在问：

  1. std::variant将 a 存储为成员的正确方法是什么？
  2. Container在允许安全复制/移动分配之前必须实施什么？
#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;
}
4

3 回答 3

12

cppreferencestd::variant对' 的复制构造函数有这样的说法：

复制构造函数。[...] 这个构造函数被定义为已删除，除非std::is_copy_constructible_v<T_i>所有T_iin都为真Types。[...]

换句话说，除非can 包含的一种或多种类型由于某种原因不可复制，否则它不会被删除。std::variant在你的情况下，这std::unique_ptr是导致问题的原因。也许std::shared_ptr会更合适。

于 2020-10-10T01:53:06.540 回答
3

扩展保罗桑德斯的回答：你想要什么样的副本？

如果是浅拷贝，请使用shared_ptr<A>.

如果是深拷贝，为什么没有variant<..,A>？如果原因是A多态，那么真正的问题是克隆每个派生类。您必须创建自己的克隆机制和自己的可复制智能指针才能使用它 - 据我所知，标准库中没有任何东西可以帮助您。

于 2020-10-10T02:04:38.240 回答
-1

您已经获得的另一个补充：您需要自己实现复制，因为no std::unique_ptr是可复制的。

Container在允许安全复制/移动分配之前必须实施什么？

对于您的特定情况，A复制构造在哪里并且您希望支持复制，它可能如下所示：

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指针并取消引用它（*）并让复制构造函数A完成其工作。

这样做没有额外的风险。取消引用unique_ptr会得到你A&提供的东西，make_unique然后将它转发给A正在构建的东西。这是简单的复制，没有任何魔法。

一种稍微复杂一点的方法可能是创建自己的unique_ptr包装器，允许复制并在您的应用程序中使用它variant。

例子：

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;
};
于 2020-10-10T02:08:29.733 回答