C++实现拷贝构造函数的方法详解

2024-04-02 19:04:59 214人浏览安东尼

摘要

目录引入一.什么是拷贝构造函数二.什么情况下使用拷贝构造函数三.使用拷贝构造函数需要注意什么四.深拷贝浅拷贝4.1 浅拷贝4.2 深拷贝引入对于普通类型的对象来说，他们之间的复制很

引入

对于普通类型的对象来说，他们之间的复制很简单：

int a = 10;
int b = a;

但是对于类对象来说，其中会存在许多的成员变量。

#include <iOStream>
using namespace std;

class CExample {
private:
    　int a;
public:
      //构造函数
    　CExample(int b)
    　{ a = b;}

      //一般函数
    　void Show ()
    　{
        cout<<a<<endl;
      }
};

int main()
{
    　CExample A(100);
    　CExample B = A; //注意这里的对象初始化要调用拷贝构造函数，而非赋值
    　 B.Show ();
    　return 0;
}

从以上代码可以看出系统为对象 B 分配了内存并完成了与对象 A 的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。

下面这个则是拷贝构造函数的工作过程

#include <iostream>
using namespace std;

class CExample {
private:
    int a;
public:
    //构造函数
    CExample(int b)
    { a = b;}
    
    //拷贝构造函数
    CExample(const CExample& C)
    {
        a = C.a;
    }

    //一般函数
    void Show ()
    {
        cout<<a<<endl;
    }
};

int main()
{
    CExample A(100);
    CExample B = A; // CExample B(A); 也是一样的
     B.Show ();
    return 0;
}

在这里CExample(const CExample& C)　就是我们自定义的拷贝构造函数。

一.什么是拷贝构造函数

同一个类的对象在内存中有完全相同的结构，如果作为一个整体进行复制或称拷贝是完全可行的。这个拷贝过程只需要拷贝数据成员，而函数成员是共用的(只有一份拷贝)。在建立对象时可用同一类的另一个对象来初始化该对象的存储空间，这时所用的构造函数称为拷贝构造函数。

拷贝构造函数本质上来说也是构造函数。

二.什么情况下使用拷贝构造函数

一般来说有以下三种情况：

用旧对象去初始化新对象
值传递—参数是类类型的值类型，从实参传递给形参的过程，是用实参去构造形参
函数返回值是值类型–用局部对象去构造临时对象调用拷贝构造

class A
{
public:
    A(int i = 0):m_i(i)
    {
        cout<<"A(int) "<<m_i<<endl;
    }
    A(const A &a):m_i(a.m_i)
    {
        cout<<"A(A) "<<m_i<<endl;
    }
    ~A()
    {
        cout<<"~A "<<m_i<<endl;
    }
private:
    int m_i;
};
void fn(A t) //2.将c传递给t的过程，是值传递，此时临时对象形参t是新对象，用c去构造t，调用拷贝构造
{
    cout<<"fn end"<<endl;
    //在退出fn函数时，将临时对象t释放，调用析构函数
}
A test()
{
    A d(40); //调用普通构造A(int)构造对象d
    return d;
    
}
A fnn()
{
    A s(50); //A(int) 50
    return s; //
    
}
void main()
{
    A a(20);  //A(int) 20
    A b = a;  //1.用a初始化b A(A)
    cout<<"fn"<<endl;
    A c(30); //A(int) 30
    fn(c);
    cout<<"test"<<endl;
    c = test(); //临时对象将值赋给c(调用赋值函数)之后，调用析构，析构临时对象
    cout<<"fnn"<<endl;
    A t = fnn(); //临时对象初始化新对象t,是否会调用拷贝构造?--调用了，不过编译器做过优化
    cout<<"main end"<<endl;
}

三.使用拷贝构造函数需要注意什么

拷贝构造函数是构造函数的一个重载形式。

拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，称为:位拷贝。

四.深拷贝浅拷贝

4.1 浅拷贝

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，指针，那么浅拷贝就会出现一些问题。

对于下面函数来说有指针作为数据成员，则用s1对象去构造s2对象的时候，调用默认拷贝构造，用s1中的数据成员指针m_str去初始化s2对象中的数据成员m_str，即是s2.m_str = s1.m_str,那么导致两个对象中的指针指向同一块内存单元，指向的都是构造s1对象时开辟的内存单元,所以在主函数退出时候要析构s2和s1时，将同一段空间释放两次出现内存错误。

class Str
{
public:
    Str(const char *str = "")
    {
        m_str = new char[strlen(str)+1];
        strcpy(m_str,str);
    }
    ~Str()
    {
        delete[]m_str;
    }
    void Print()
    {
        cout<<m_str<<endl;
    }
private:
    char *m_str;
};
void main()
{
    Str s1("pangpang");
    Str s2(s1);
    cout<<sizeof(Str)<<endl;
    s1.Print();
    s2.Print();
}

上述程序的内存布局：

对于指针作为数据成员的类，用s1对象去构造s2对象的时候，调用默认拷贝构造函数时，二者指向同一内存单元，即二者的初始地址相同这里均为0X0002000，当我们构造完以后将要进行析构时，这里将会出现错误：因为析构函数要释放空间，而这里我们的空间对应的是一块空间，当我们析构完s2后：这一块空间的内容已经被delete，而我们还需要析构s1，即：一个内存空间析构了两次，出现内存错误。

为了解决上述问题我们就需要给s2中的m_str也开辟和s1中的m_str一样大小的空间，所以我们就需要深拷贝。

4.2 深拷贝

在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：

class Str
{
public:
    Str(const char *str = "")
    {
        m_str = new char[strlen(str)+1];
        strcpy(m_str,str);
    }
    ~Str()
    {
        cout<<"~Str"<<endl;
        delete[]m_str;
    }
    Str(const Str& s)
    {
        cout<<"Str(Str)"<<endl;
        m_str = new char[strlen(s.m_str)+1]; //开辟同样大小的空间
        strcpy(m_str,s.m_str); //将内容拷贝成一样的
    }
    void Print()
    {
        cout<<m_str<<endl;
    }
private:
    char *m_str;
};
void main()
{
    Str s1("pangpang");
    Str s2(s1); //拷贝构造
    s1.Print();
    s2.Print();
}

现在的程序内存布局为：