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

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

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;
/*
 3.在返回的时候，将局部对象的值给了临时对象(值传递，调用拷贝构造，用旧局部对象去构造新的临时对象)
 然后局部对象d就释放了，临时对象将值带回到主调函数中后，临时对象的值才释放
*/
}
A fnn()
{
A s(50); //A(int) 50
return s; //
/*1.s->临时对象  拷贝构造
2.析构函数局部对象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();
}

现在的程序内存布局为：