[C++知识库] c++ 拷贝构造函数的一点理解

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> c++ 拷贝构造函数的一点理解 -> 正文阅读

[C++知识库]c++ 拷贝构造函数的一点理解

函数形参，分配内存有3种情况：

定义形参类型是值传递：函数调用时分配内存；
定义形参类型是引用传递：函数调用时不分配内存。
定义形参类型是指针传递：函数调用时不分配内存。

1、定义形参类型是值传递，函数调用分配内存，如下

定义一个函数

int func(int a)
{
    printf("value=%d\n",a);
    return 0;
}

当函数调用时，

func(2);

实际执行如下

{
    a = 2;
    printf("value=%d\n",a);
    return 0;
}

如上，函数调用时，形参分配内存，然后将实参的值赋值给形参。

2、定义形参类型是引用传递：函数调用时不分配内存，直接使用实参进行操作

3、再来看一下类，如下

#include <iostream>
#include <cstdlib>
using namespace std;

//变长数组类
class Array{
public:
    Array();
    Array(int len);
    Array(const Array &arr);  //拷贝构造函数
    ~Array();
private:
    int m_len;
    int *m_p;
};

Array::Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::Array(int len): m_len(len)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    m_p = (int*)calloc( len, sizeof(int) );
}

Array::Array(const Array &arr){  //拷贝构造函数
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::~Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array func(Array arr)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    Array ret;
    printf("%s %d\n",__FUNCTION__,__LINE__);
    ret = arr;
    printf("%s %d\n",__FUNCTION__,__LINE__);
    return ret;
}

int main(){
    Array a(10);
    func(a);
    printf("%s %d\n",__FUNCTION__,__LINE__);

    return 0;
}

?执行后打印如下

Array 24 ? ? ? ?第48行创建对象a，调用的类构造函数
Array 29 ? ? ? ?第49行a作为实参传递给func函数时，a拷贝给arr，调用拷贝函数
func 39 ? ? ? ? func函数体内第一次打印
Array 19 ? ? ? ?第40行创建对象ret，调用构造函数
func 41 ? ? ? ? func函数体内第二次打印
func 43 ? ? ? ? func函数体内第三次打印
~Array 34 ? ? ? func函数退出，ret析构
~Array 34 ? ? ? func函数退出，arr析构
main 50
~Array 34 ? ? ? main函数退出，a析构

func函数定义为引用类型形参，如下

#include <iostream>
#include <cstdlib>
using namespace std;

//变长数组类
class Array{
public:
    Array();
    Array(int len);
    Array(const Array &arr);  //拷贝构造函数
    ~Array();
private:
    int m_len;
    int *m_p;
};

Array::Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::Array(int len): m_len(len)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    m_p = (int*)calloc( len, sizeof(int) );
}

Array::Array(const Array &arr){  //拷贝构造函数
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::~Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array func(Array &arr)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    Array ret;
    printf("%s %d\n",__FUNCTION__,__LINE__);
    ret = arr;
    printf("%s %d\n",__FUNCTION__,__LINE__);
    return ret;
}

int main(){
    Array a(10);
    func(a);
    printf("%s %d\n",__FUNCTION__,__LINE__);

    return 0;
}

打印如下

Array 24
func 39
Array 19
func 41
func 43
~Array 34
main 50
~Array 34?

与按值类型传递，少了2个打印

Array 29 ? ? ? 第49行a作为实参传递给func函数时，a拷贝给arr，调用拷贝函数

~Array 34 ? ? ?func函数退出，arr析构?

可以看出，按引用传递时，少了一次对象构造和析构，即形参没有单独创建一次对象，没有执行拷贝动作，这就是按引用类型传递参数的好处，减少一次拷贝过程。?

4、基于以上按引用类型传递形参的代码，?此时，析构函数添加一条释放指针的操作，如下

Array::~Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    free(m_p);
}

则执行结果如下

Array 24
func 40
Array 19
func 42
func 44
~Array 34
main 51
~Array 34
dlmalloc abort!

main函数退出，对象a析构时出错。原因是，如果不定义拷贝构造函数（即? 使用默认拷贝构造函数）或者定义的拷贝构造函数里没有对指针做特别处理，那么，拷贝的执行动作，就是简单的成员变量对等赋值。也就是说，ret.m_p =?arr.m_p，即 ret.m_p =?a.m_p。那么，当ret析构时，执行了内存释放动作free(m_p)。a析构时再次执行内存释放就出错了。

为了解决不同对象之间相互干扰，修改一个对象的数据会影响另外的对象这个问题，就需要定义拷贝构造函数，对于类中的指针或者其他资源进行处理，如下定义拷贝构造函数

Array::Array(const Array &arr)//拷贝构造函数
{  
    this->m_len = arr.m_len;
    this->m_p = (int*)calloc( this->m_len, sizeof(int) );
    memcpy( this->m_p, arr.m_p, m_len * sizeof(int) );
}

以上的拷贝构造函数，对于普通成员函数进行赋值；对于指针，则申请独立空间，并把形参的数据赋值过来。这样一来，形参析构时，不会对本对象造成影响。

以上修改拷贝构造函数之后，对应func函数也需要修改一下，使用拷贝构造的方式来创建对象ret，如下

Array func(Array &arr)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    Array ret = arr;
    return ret;
}

整体修改后的代码如下

#include <iostream>
#include <cstdlib>
#include <string.h>
using namespace std;

//变长数组类
class Array{
public:
    Array();
    Array(int len);
    Array(const Array &arr);  //拷贝构造函数
    ~Array();
private:
    int m_len;
    int *m_p;
};

Array::Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
}

Array::Array(int len): m_len(len)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    m_p = (int*)calloc( len, sizeof(int) );
}

Array::Array(const Array &arr)//拷贝构造函数
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    this->m_len = arr.m_len;
    this->m_p = (int*)calloc( this->m_len, sizeof(int) );
    memcpy( this->m_p, arr.m_p, m_len * sizeof(int) );
}

Array::~Array()
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    free(m_p);
}

Array func(Array &arr)
{
    printf("%s %d\n",__FUNCTION__,__LINE__);
    Array ret = arr;
    return ret;
}

int main(){
    Array a(10);
    func(a);
    printf("%s %d\n",__FUNCTION__,__LINE__);

    return 0;
}

执行结果如下