C++ 中类的复制构造函数

我不知道你为什么决定使用原始指针而不是 s。unique_ptr

unique_ptr具有 RAII 功能，这意味着当超出范围时，它们会自动销毁指向的资源以及指针。

相反，使用原始指针时，您需要手动使用它们。此外，如果将它们用作自定义类中的数据成员，则还需要定义自己的&构造函数和赋值运算符。deletecopymove

一种方法（我听说在Java中是臭名昭著的，在C++中更不用说了）将允许您根据代码的需要执行深度复制。clone()vector<Widget*>

如果按如下方式修改，该程序应该可以工作：

#include <iostream>
#include <vector>
#include <utility>
#include <stdexcept>

using std::cout;
using std::vector;
using std::move;
using std::exception;
using std::logic_error;

class Widget
{
public:
    Widget() {cout << "created Base Widget\n";}
    Widget(const Widget& original) noexcept {
        cout << "copied Base Widget\n";
    }

    virtual ~Widget(){} // need virtual destructor with class hierarchy

    virtual Widget* clone() const { // makes deep copies of pointers
        if constexpr(noexcept(Widget(*this))) {
            try {
                cout << "cloned Widget\n";
                return new Widget(*this);
            } 
            catch(exception& e) {
                throw runtime_error("error occurred while cloning Widget");
            }
        } else 
            throw logic_error("Widget: Faulty constructor");           
    }
};

class Button: public Widget{
public:
    Button(): Widget() { cout << "created Button\n"; }
    Button(const Button& original) noexcept: Widget(original){ 
        cout << "copied Button\n";
    }
    
    virtual Button* clone() const {
        if constexpr(noexcept(Button(*this))) {
            try {
                cout << "cloned Button\n";
                return new Button(*this);
            } 
            catch(exception& e) {
                throw runtime_error("error occurred while cloning Button");
            }
        } else 
            throw logic_error("Button: Faulty constructor");           
    }
    
    virtual ~Button(){}
};

class Label: public Widget {
public:
    Label(): Widget() { cout << "created Label\n"; }
    Label(const Label& original) noexcept: Widget(original){
        cout << "copied Label\n";
    }
    
    virtual Label* clone() const {
        if constexpr(noexcept(Label(*this))) {
            try {
                cout << "cloned Label\n";
                return new Label(*this);
            } 
            catch(exception& e) {
                throw runtime_error("error occurred while cloning Label");
            }
        } else 
            throw logic_error("Label: Faulty constructor");
    }
    
    virtual ~Label(){}
};

class Plane { // destructor is needed so copy&move semantics are also needed
              // (rule of 5)
    vector<Widget*>vec;
public:
    Plane(): vec(0) {}

    Plane(const Plane& original)  // performs deep copy
    {   
        vec.resize(original.vec.size());
        for (size_t i = 0; i != original.vec.size(); ++i) 
            vec[i] = original.vec[i]->clone();
    }

    Plane& operator=(const Plane& original)
    {   
        if (this != &original) {
            vec.resize(original.vec.size());
            for (size_t i = 0; i != original.vec.size(); ++i) 
                vec[i] = original.vec[i]->clone();
        }

        return *this;
    }

    ~Plane() {
        for (auto w: vec) {
            delete w;
            cout << "deleted Widget\n";
        }
    }

    // for completeness also add move semantics
    Plane(Plane&& original) noexcept
    {
        vec = move(original.vec);
        cout << "moved Plane\n";
    }

    Plane& operator=(Plane&& original) noexcept
    {
        if (this != &original)
            vec.swap(original.vec);

        return *this;
    }

    void Add (Widget* w) {
        vec.push_back(w);
        cout << "added Widget*\n";
    }
};

int main () {
   Plane p1;
   p1.Add(new Button);
   p1.Add(new Label);
   Plane p2(p1);
   
   return 0;
}

结果符合预期：四个 s 是 d（两个 in 和 2 个 inWidgetdeletep1p2)

created Base Widget
created Button
added Widget*
created Base Widget
created Label
added Widget*
cloned Button
copied Base Widget
copied Button
cloned Label
copied Base Widget
copied Label
deleted Widget
deleted Widget
deleted Widget
deleted Widget