在复制构造函数中做指针的深度复制向量是否更改了两个向量成员？-解网

问：

我需要在我的项目中进行深度复制，现在我进入了如果拥有指针成员，我只需创建所有 obj 并以递归方式执行此方法memcpysrcObjdestObjdestObj

这是伪：

class B
{
public:
    B(int id_) : id(id_) {};
    int id = 0;
};

class A
{
public:
    vector<B*> vecInt;
    B objB = 111;
    A()
    {
        vecInt.push_back(new B(1));
        vecInt.push_back(new B(2));
        vecInt.push_back(new B(3));
    }
    A(const A& rhs)
    {
        memcpy(this, &rhs, sizeof(A));
        for (auto i = 0; i < rhs.vecInt.size(); i++)
        {
            auto ptrTmp = new B(rhs.vecInt[i]->id);
            cout << "00000000000 " << rhs.vecInt[i] << endl;;
            this->vecInt[i] = ptrTmp;
            cout << "11111111111 " << ptrTmp << endl;;
            cout << "22222222222 " << rhs.vecInt[i] << endl;;
        }
    }
};

这就是问题所在，每次我在循环中分配时，更改也会发生，并且它们都指向一个地址，我不知道为什么会发生这种情况。this->vecInt[i]rhs.vecInt[i]

感谢任何帮助。

C++ 矢量复制构造函数 deep-copy

class A
{
public:
    vector<B*> vecInt;
    B objB = 111;

    A()
    {
        vecInt.push_back(new B(1));
        vecInt.push_back(new B(2));
        vecInt.push_back(new B(3));
    }

    A(const A& rhs) : objB(rhs.objB)
    {
        vecInt.reserve(rhs.vecInt.size());
        for (auto *elem : rhs.vecInt)
        {
            vecInt.push_back(new B(*elem));
        }
    }

    A(A&& rhs) : vecInt(move(rhs.vecInt)), objB(move(rhs.objB)) {}

    ~A()
    {
        for(auto *elem : vecInt)
            delete elem;
    }

    A& operator=(A rhs)
    {
        vecInt.swap(rhs.vecInt);
        objB.id = rhs.objB.id;
        return *this;
    }
};

话虽如此，请考虑使用代替 .这将消除对显式析构函数的需求。如果可以避免，请不要在现代 C++ 中使用 /。std::vector<std::unique_ptr<B>>std::vector<B*>newdelete

class A
{
public:
    vector<unique_ptr<B>> vecInt;
    B objB = 111;

    A()
    {
        vecInt.push_back(make_unique<B>(1));
        vecInt.push_back(make_unique<B>(2));
        vecInt.push_back(make_unique<B>(3));
    }

    A(const A& rhs) : objB(rhs.objB)
    {
        vecInt.reserve(rhs.vecInt.size());
        for (auto &elem : rhs.vecInt)
        {
            vecInt.push_back(make_unique<B>(*elem));
        }
    }

    A(A&& rhs) : vecInt(move(rhs.vecInt)), objB(move(rhs.objB)) {}

    ~A() = default;

    A& operator=(A rhs)
    {
        vecInt.swap(rhs.vecInt);
        objB.id = rhs.objB.id;
        return *this;
    }
};

更好的是，改用，让编译器为你处理其他所有事情：std::vector<B>

class A
{
public:
    vector<B> vecInt;
    B objB = 111;

    A()
    {
        vecInt.emplace_back(1);
        vecInt.emplace_back(2);
        vecInt.emplace_back(3);
    }
};

感谢您的帮助，我还没有注意到它是如此恶毒，它现在可以工作了，但是由于我需要为某些对象使用太多指针，我想我只是无法实现最后一个。但是既然现在不能使用，那么我应该一个接一个地分配所有数据成员，我只是觉得这真的很难维护，还是有其他方法可以处理这么多数据成员的情况？memcpymemcpy

上一个：C++ 我的复制构造函数无法将内存移动到新区域

下一个：为什么当我尝试向向量添加元素时会调用我的复制构造函数？

在复制构造函数中做指针的深度复制向量是否更改了两个向量成员？

doing deep copy vector of pointers in copy constructor got both vector member changed?

评论

评论