如何做一个向量 <class objects*> 深拷贝

Question

当涉及到类对象的指针的矢量时，我很难编写三个规则。 搜索过的示例似乎并不适用。 我有以下三个课程：

class Data
{
    private:
        map<string, double> m_DataVariables;

    public:
        Data();
        Data(const Data &data);
 };

class Sample
{
    private:
        Data *m_pData;

    public:
        virtual ~Sample()
        {
            delete m_pData;
        }

    Sample();
    Sample(const Sample &sample);
};

class BuildTree
{
    private:
        vector<Sample*> BuildSamples;

    public:
        BuildTree(vector<Sample*> &Samples);

        // This does not compile
        BuildTree(const BuildTree& other) : BuildSamples(new(other.BuildSamples))
        {
        } 

        ~TreeBuilding()                                         
        {   
            for (int i = 0; i < BuildSamples.size(); ++i)
                delete BuildSamples[i];
        }

        void BuildTrees(void);
};

1-不确定我是否正确删除BuildSamples。

2-在构造函数中，要对传递的参数进行深拷贝到成员变量BuildSamples中。

BuildTree::BuildTree(vector<Sample*> &samples)
{
    BuildSamples = samples;  // This just copies the references
} 

如何编写复制构造函数以进行深复制？ 我在这里想念什么？

3-请注意：无法访问智能指针，share_ptr或unique_ptr等。C ++ 98是我所拥有的。 请显示执行此操作所需的步骤。 真的感谢您的时间和考虑。

Answer 1

您可能想要类似的东西：

BuildTree(const BuildTree& other)
{
    BuildSamples.reserve(other.BuildSamples.size());
    for (std::size_t i = 0; i != other.BuildSamples.size(); ++i) {
        BuildSamples.push_back(new Sample(*other.BuildSamples[i]));
    }
}

BuildTree(const vector<Sample*> &samples)
{
    BuildSamples.reserve(samples.size());
    for (std::size_t i = 0; i != samples.size(); ++i) {
        BuildSamples.push_back(new Sample(*samples[i]));
    }
}

Answer 2

我注意到您将您的问题标记为c ++ 98 ； 即使C ++ 98不支持std::智能指针，也可以使用Boost中定义的智能指针，例如boost::shared_ptr 。 例如，您可以使用vector<boost::shared_ptr<Sample>>简化代码，而不是像vector<Sample*>那样使用原始拥有的指针。

这样，复制和销毁操作将在后台自动执行。

Answer 3

您需要将BuildSamples成员初始化为指针向量，并确保每个指针都指向传递的对象的克隆。 一种方法是

BuildTree(const BuildTree& other) : BuildSamples(other.BuildSamples)
{
     std::vector<Sample *>::iterator i = BuildSamples.begin(), end = BuildSamples.end();
     while (i != end)
     {
         *i = new Sample(**i);
         ++i;
     }
}

BuildSamples(other.BuildSamples)使用BuildSamples以正确数量的元素初始化BuildSamples ，但这些元素与other.BuildSamples指针相同。 这样可以确保向量的大小正确，而不必担心显式设置大小。 那是浅表。 然后，构造函数的主体将设置BuildSamples每个元素，使其指向其自身的副本-从而完成深层副本。

构造函数BuildTree(const std::vector<Sample *> &)可以类似的方式实现。

注意：鉴于您的类正在实现一个非平凡的副本构造函数（以进行深层复制）和一个析构函数进行清理，因此您还需要实现一个赋值运算符BuildTree &operator=(const BuildTree &) 。 有关原因的解释，请查找“三个规则”。

Answer 4

在处理指针并避免由于调用析构函数而导致正在运行的程序崩溃时，必须使用深度复制！ 深度复制允许创建指向新分配空间的新指针。 但是，当将对象作为向量中的R值传递时，最好使用move构造函数。

    #include <iostream>
    #include <string>
    #include <vector>
    using namespace std;
    class example{
        private:
         int *pointer;
    public:
        //constructor
        example(int d){
            pointer = new int;
            *pointer = d;
            cout<<"Constructor Called"<<endl;
        }


    // deep copy
        example(const example &source){
            pointer = new int;
            *pointer= *source.pointer;
            cout<<"deep copy made"<<endl;
        }
    // Move Constructor
        example(example &&source) noexcept :pointer{source.pointer}{
        source.pointer = nullptr;
        cout << "object moved"<<endl;
        }
// Destructor
        ~example() {
            delete pointer;
            cout << "Destroyed"<<endl;
        }

    };

    int main()
    {

        vector <example> vec;
        vec.push_back(example{300});
        vec.push_back(example{300});
        vec.push_back(example{300});
        vec.push_back(example{300});
        return 0;
    }