0

在下面的示例中，我们有一个Class包含一个Bridge对象的类，该对象为我们处理所有内存处理（三规则）。

class Base {
public:
    Base() {};
    virtual Base* clone() const = 0;
    virtual ~Base() {};
};

class Derived : public Base {
public:
    Derived() {};
    virtual Base* clone() const {
        return new Derived(*this);
    }
    virtual ~Derived() {}
};

class Bridge {
public:
    Bridge(const Bridge& bridge_) {
        base = bridge_.base->clone();
    }
    Bridge(const Base& base_) {
        base = base_.clone();
    }
    ~Bridge() { delete base; }
    
    Bridge& operator=(const Bridge& assignFrom) {
        if(this != &assignFrom) {
            delete base;
            base = assignFrom.base->clone();
        }
        return *this;
    }
private:
    Base *base;
};

class Class {
public:
    Class(const Bridge& bridge_) : bridge(bridge_) {};
private:
    Bridge bridge;
};

int main()
{
    Derived derived;
    Class c(derived);
    Class c1(c);  
}

现在，我刚刚了解了智能指针，并尝试使用unique_ptr. 据我了解，我们基本上不需要自己实现 3 规则，因为智能指针已经包含它。为了测试这一点，我做了以下示例：

class BaseSMRT {
public:
    BaseSMRT() {};
    virtual std::unique_ptr<BaseSMRT> clone() const = 0;
    virtual ~BaseSMRT() {};
};

class DerivedSMRT : public BaseSMRT {
public:
    DerivedSMRT() {};
    virtual std::unique_ptr<BaseSMRT> clone() const {
        return std::make_unique<DerivedSMRT>(*this);
    }
    virtual ~DerivedSMRT() {}
};

class ClassSMRT {
public:
    ClassSMRT(const BaseSMRT& base) {
        ptr = base.clone();
    };
private:
    std::unique_ptr<BaseSMRT> ptr;
};

int main()
{
    DerivedSMRT derivedSMRT;
    ClassSMRT cSMRT(derivedSMRT);
    ClassSMRT cSMRT2(cSMRT); // error: Call to implicitly-deleted copy constructor of 'ClassSMRT'
}

正如您在上面的示例中所看到的，cSMRT2通过cSMRT复制构造函数进行初始化不起作用并给出了上述错误。

我不明白：为什么我可以Class像这样调用 的默认复制构造函数Class c1(c);，但不能调用ClassSMRT默认的复制构造函数ClassSMRT cSMRT2(cSMRT);？

这表明我们在使用unique_ptr.

4

1 回答 1

2

unique_ptr旨在阻止意外复制。您希望在复制时隐式克隆您的多态类型。unique_ptr不（直接）适合您的用途。

我建议重命名Bridge

template </*Cloneable*/ typename T>
class clone_ptr {
public:
    clone_ptr(const T& base_) 
      : base(base_.clone()) {}
    clone_ptr(const clone_ptr& other)
      : base(other.base->clone()) {}
    clone_ptr(clone_ptr&& other) = default;
    
    clone_ptr& operator=(clone_ptr other) {
        base = std::move(other.base);
        return *this;
    }
private:
    std::unique_ptr<T> base;
};
于 2020-09-25T08:17:27.033 回答