一、要点归纳

1. 对象之间的复制操作

  同一个类的对象之间可以进行复制操作，即将一个对象数据成员复制给另一个对象的相应的数据成员。

1.1 =运算符

  当已经定义了同一个类的多个对象时，可以在这些对象之间进行赋值运算，通常采用=运算符来实现，例如：

MyClass s1,s2;
s1=s2;

  上述对象复制语句的功能只是将s2的所有数据成员赋值给s1相应的数据成员。如果程序员在类中没有定义=运算符，编译器会相建立默认构造函数那样建立一个默认的=运算符。实际上，=运算符对应operator=成员函数，所谓定义=运算符就是重载operator=成员函数。

1.2 拷贝构造函数

  如果创建新对象并赋值，调用拷贝构造函数。在定义新对象并初始化时，形如A x=y的语句是通过调用拷贝构造函数创建对象x，通常将对象y的数据成员赋值给对象x相应的数据成员，例如有以下程序：

class A
{int m;public:A(){m = 0;std::cout << "默认构造函数" << std::endl;}~A(){std::cout << "析构函数" << std::endl;}A(int n){m = n;std::cout << "重载构造函数" << std::endl;}A(const A &b){std::cout << "拷贝构造函数" << std::endl;}A &operator=(const A &b){std::cout << "operator=" << std::endl;return *this;}
};void test01()
{A a(2), b(a), c;c = a;A d = a;
}

输出结果如下：

重载构造函数
拷贝构造函数
默认构造函数
operator=
拷贝构造函数
析构函数
析构函数
析构函数
析构函数

  建立A a(2)调用重载构造函数，执行b(a)调用拷贝构造函数，执行A c调用默认构造函数。执行c=a调用operator=成员函数，执行A d=a调用拷贝构造函数。依次销毁d\c\b\a调用析构函数。

2. 对象之间的浅复制和深复制

  无论是拷贝构造函数还是=运算符，都可春实现对象复制。对象复制又分为浅复制和深复制。

2.1 对象的浅复制

  当两个对象之间进行复制时，若复制完成后她们还共享某些资源（内存空间），其中一个对象的销毁会影响另一个对象，这种对象之间的复制称为浅复制。例如有以下程序：

class Student
{int no;char *pname;public:Student() {}            // 默认构造函数Student(int n, char *p) // 重载构造函数{no = n;pname = new char[10]; // 用new分配内存空间strcpy(pname, p);}Student(Student &s) // 拷贝构造函数{no = s.no;pname = s.pname;}void display(){std::cout << "no:" << no << ",name:" << pname << std::endl;std::cout << "pname:" << (int *)pname << std::endl; // 输出pname地址}
};
void test02()
{Student s(10, (char *)"Mary"), t(s);std::cout << "s:";s.display();std::cout << "t:";t.display();
}

输出如下：

s:no:10,name:Mary
pname:0x55d1366c22c0
t:no:10,name:Mary
pname:0x55d1366c22c0

在上述程序中先声明了一个类Student，其中有一个拷贝构造函数。在main函数中建立了一个对象s，通过拷贝构造函数由s建立t对象。由Student类的拷贝构造函数可以看到s到t的复制是浅复制，如下图所示，因为这两个对象的pname数据成员均指向相同的内存空间。

2.2 对象的深复制

  当两个对象之间进行复制时，若复制完成后她们不会共享任何资源（内存空间），其中一个对象的销毁不会影响到另一个对象，这种对象之间的复制称为深复制。例如将上述程序修改如下：

class Student
{int no;char *pname;public:Student() {}            // 默认构造函数Student(int n, char *p) // 重载构造函数{no = n;pname = new char[10]; // 用new分配内存空间strcpy(pname, p);}Student(Student &s) // 拷贝构造函数{no = s.no;// pname = s.pname;pname = new char[strlen(s.pname + 1)];strcpy(pname, s.pname);}void display(){std::cout << "no:" << no << ",name:" << pname << std::endl;std::cout << "pname:" << (int *)pname << std::endl; // 输出pname地址}~Student() { delete pname; } // 析构函数
};void test03()
{Student s(10, (char *)"Mary"), t(s);std::cout << "s:";s.display();std::cout << "t:";t.display();
}

s:no:10,name:Mary
pname:0x55acd2a8b2c0
t:no:10,name:Mary
pname:0x55acd2a8b2e0

修改后类Student的亏被构造函数在复制数据成员pname时另外开辟内存空间，从而当执行Student s(10, (char *)“Mary”), t(s);的时候由对象s复制产生对象t时，这两队对象的pname成员分别指向不同的内存单元，如图？

二、面试真题解析

面试题1

【面试题】什么时候必须重写拷贝构造函数？
【答】当构造函数涉及动态存储分配空间时要自己写拷贝构造函数，并且要深复制。

面试题2

【面试题】不考虑任何编译器优化，下面代码的第8行会发生（一次拷贝构造、一次析构函数、一次operator=）

#include <iostream>
class B
{
};
B func(const B & rhs)
{return rhs;
}
void main()
{B b1,b2;b2=func(b1);
}

【答】首先调用一次拷贝构造函数将b1复制给形参rhs，返回rhs并赋值给b2调用一次operator=，func函数执行完毕销毁rhs调用一次析构函数。