对象=拷贝构造，有无指针成员的不同之处

原创已于 2023-04-23 21:16:21 修改 · 636 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #数据结构 #开发语言

于 2023-04-23 21:09:33 首次发布

文章讨论了在C++中，当类包含指针成员时，编译器默认的浅拷贝可能引发的问题。如果类中有动态分配的内存，需要自定义拷贝构造函数和赋值运算符来实现深拷贝，以避免数据丢失或内存泄漏。示例代码展示了如何正确实现这两个函数。

比如类Add，Add A=B:

1、当新声明一个对象并赋初始值时，使用=时，编译器会默认，将B的成员变量，拷贝赋值给B，使用的是浅拷贝，该函数自己不写到类内部时，编译器会默认隐式自带；

Add(const Add& n)

2、假如类内部没有成员是指针类型，编译器的默认拷贝赋值是没有问题的，使用的浅拷贝；

3、假如类内部有成员是指针类型，那么编译器再使用浅拷贝，拷贝指针成员时，仅会将该指针的的值拷贝赋值给目的对象，而指针指向的空间内的数据，不会被拷贝；

这个时候，编译器默认自带的拷贝赋值函数，就不能满足要求，这个时候就需要我们自己，自定义改写这个函数Add(const Add& n)；

4、我们写的类成员函数void operator=(Add n)，在什么情况下才会被调用呢，只有在前面类对象已经存在，再次拷贝赋值的时候才会调用；

总结：假设B已提前存在

①、

Add A=B:

调用 Add(const Add& n)；

②、

Add A；

A = B；

调用 void operator=(Add n)；

#include <iostream>


using namespace std;


class Add
{
public:
    Add(int n)
    {
        m_Num = new int;
        *m_Num = n;
    }

    Add(const Add& AA)
    {
        if(AA.m_Num)
        {
            m_Num = new int;
            *m_Num = *AA.m_Num;
        }else{
            m_Num = nullptr;
        }
    }

    Add& operator=(Add& AA)
    {
        if (this == &AA)
        {
            return *this;
        }

        if (AA.m_Num)
        {
            delete m_Num;
            m_Num = new int;
            *m_Num = *AA.m_Num;
        }else{
            m_Num = nullptr;
        }
        return *this;
    }

    ~Add()
    {
        if (m_Num != NULL)
        {
            delete m_Num;
            m_Num = NULL;
        }

    }
    int* m_Num;
};

void test01()
{
    Add n1(10);
    Add n2(20);
    n1 = n2;
    Add n3 = n2;
    cout << *n1.m_Num << endl;

}
int main()
{
    test01();
    return 0;
}

显然，编译器默认的隐式拷贝构造函数是不能满足我们的需要的，那么这时，就需要我们自己写拷贝赋值函数了：