C++类默认拷贝函数的弊端

最新推荐文章于 2024-05-29 18:31:18 发布

nzlcsdn

最新推荐文章于 2024-05-29 18:31:18 发布

阅读量211

点赞数

分类专栏： C++

原文链接：https://blog.csdn.net/qq_29344757/article/details/76037255

版权

C++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文链接： https://blog.csdn.net/qq_29344757/article/details/76037255

1. c++类的默认拷贝构造函数的弊端

c++类的中有两个特殊的构造函数，(1)无参构造函数，(2)拷贝构造函数。它们的特殊之处在于：
(1)当类中没有定义任何构造函数时，编译器会默认提供一个无参构造函数且其函数体为空；
(2)当类中没有定义拷贝构造函数时，编译器会默认提供一个拷贝构造函数，进行成员变量之间的拷贝。(这个拷贝操作是浅拷贝)

这里只讲拷贝构造函数。在c语言中，

int a = 5;  //初始化
int b;
b = 6;      //赋值
 
 
 
 1
2
3

上面的初始化及赋值操作是最正常不过的语法，c++语言肩挑兼容c语言语法的责任，所以在类的设计上，也兼容这种操作：

class cls
{
pubic:
    //...
}

int main(void)
{
    cls c1;
    cls c2 = c1;    //初始化类，还可以 cls c2(c1);
    cls c3;

    c3 = c1;        //赋值类

    //...

    return 0;
}
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

如上的初始化类需要调用到cls类的默认实现的拷贝构造函数，为类赋值需要调用的是cls类的默认实现的赋值操作符重载函数，它们都是浅度拷贝的。前者其原型为：

cls(const cls& c)
 
 
 
 1

默认的拷贝构造函数存在弊端，看如下类定义：

class TestCls{
public:
    int a;
    int *p;

public:
    TestCls()   //无参构造函数
    {
        std::cout<<"TestCls()"<<std::endl;
        p = new int;
    }

    ~TestCls()     //析构函数
    {
        delete p;   
        std::cout<<"~TestCls()"<<std::endl;
    }
};

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

类中的指针p在构造函数中分配的空间，在析构函数中释放。

int main(void)
{
    TestCls t;

    return 0;
}
 
 
 
 1
2
3
4
5
6

编译运行确实不会出错：
这里写图片描述

类在我们没有定义拷贝构造函数的时候，会默认定义默认拷贝构造函数，也就是说可以直接用同类型的类间可以相互赋值、初始化：

int main(void)
{
    TestCls t1;
    TestCls t2 = t1;   //效果等同于TestCls t2(t1);

    return 0;
}
 
 
 
 1
2
3
4
5
6
7

编译通过，运行却出错了：
这里写图片描述

原因就在于，默认的拷贝构造函数实现的是浅拷贝。

2. 深度拷贝和浅拷贝

深度拷贝和浅拷贝在c语言中就经常遇到的了，在这里我简单描述。
一般的赋值操作是深度拷贝：

//深度拷贝
int a = 5;
int b = a;
 
 
 
 1
2
3

简单的指针指向，则是浅拷贝：

//浅拷贝
int a = 8;
int *p;
p = &a;
 
 
 
 1
2
3
4

char* str1 = "HelloWorld";
char* str2 = str1;
 
 
 
 1
2

将上面的浅拷贝改为深度拷贝后：

//深度拷贝
int a = 8;
int *p = new int;
*p = a;
 
 
 
 1
2
3
4

char* str1 = "HelloWorld";
int len = strlen(str1);
char *str2 = new char[len];
memcpy(str2, str1, len);
 
 
 
 1
2
3
4

稍微有点c语言基础的人都能看得出深度拷贝和浅拷贝的差异。总而言之，拷贝者和被拷贝者若是同一个地址，则为浅拷贝，反之为深拷贝。
以字符串拷贝为例，浅拷贝后，str1和str2同指向0x123456，不管哪一个指针，对该空间内容的修改都会影响另一个指针。
这里写图片描述

深拷贝后，str1和str2指向不同的内存空间，各自的空间的内容一样。因为空间不同，所以不管哪一个指针，对该空间内容的修改都不会影响另一个指针。
这里写图片描述

3. 解决默认拷贝构造函数的弊端

类的默认拷贝构造函数只会用被拷贝类的成员的值为拷贝类简单初始化，也就是说二者的p指针指向的内存空间是一致的。以前面TestCls可以知道，编译器为我们默认定义的拷贝构造函数为：

TestCls(const TestCls& testCls)
{
    a = testCls.a;
    p = testCls.p;      //两个类的p指针指向的地址一致。
}
 
 
 
 1
2
3
4
5

main函数将要退出时，拷贝类t2的析构函数先得到执行，它把自身p指向的堆空间释放了；接下来，t1的析构函数得到调用，被拷贝类t1的析构函数得到调用，它同样要去析构自身的p指向指向的堆空间，但是该空间和t2类中p指向的空间一样，造成重复释放，程序运行崩溃。

解决办法十分简单，自定义拷贝构造函数，里面用深度拷贝的方式为拷贝类初始化：

class TestCls{
public:
    int a;
    int *p;

public:
    TestCls()
    {
        std::cout<<"TestCls()"<<std::endl;
        p = new int;
    }


    TestCls(const TestCls& testCls)
    {
        std::cout<<"TestCls(const TestCls& testCls)"<<std::endl;
        a = testCls.a;
        //p = testCls.p;
        p = new int;

        *p = *(testCls.p);      //为拷贝类的p指针分配空间，实现深度拷贝
    }

    ~TestCls()
    {
        delete p;   
        std::cout<<"~TestCls()"<<std::endl;
    }
};

int main(void)
{
    TestCls t1;
    TestCls t2 = t1;

    return 0;
}
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37