拷贝构造函数
每个类都有多个构造函数和一个析构函数。此外，类还可以有一个拷贝构造函数（copy constructor）。
拷贝构造函数用于拷贝对象。也就是说，这个构造函数的参数是这个类的对象，执行这个构造函数之后，会产生一个与原来对象一样的对象（实际上是用原来对象的数据初始化了一个对象）。
构造函数的签名如下：
ClassName (const ClassName&)
下面给出一个栗子:
Circle.h
class Circle { public: //无参构造函数 Circle(); //有参构造函数 Circle(double); //析构函数 ~Circle(); //获取圆的面积 double getArea(); //获取圆的半径 double getRadius(); private: //圆的半径 double radius; //定义常量圆周率 const double PI = 3.14159; //对象个数 static int objectNumber; };
Circle.cpp
#include "Circle.h" #include <iostream> using namespace std; int Circle::objectNumber = 0; //无参构造函数 Circle::Circle() { this->radius = 1; objectNumber++; cout << "当前对象的个数是" << objectNumber << endl; } //有参构造函数 Circle::Circle(double radius) { this->radius = radius; objectNumber++; cout << "当前对象的个数是" << objectNumber << endl; } //析构函数 Circle::~Circle(){ objectNumber--; cout << "当前对象的个数是" << objectNumber << endl; } //获取面积 double Circle::getArea() { return radius*radius*PI; } //获取半径 double Circle::getRadius(){ return this->radius; }
main.cpp
#include <iostream> #include "Circle.h" using namespace std; int main() { //调用无参构造函数 cout << "创建对象p1" << endl; Circle* p1 = new Circle(2); //调用拷贝构造函数 cout << "创建对象p2" << endl; Circle* p2 = new Circle(*p1); //调用有参构造函数，参数为3 cout << "创建对象p3" << endl; Circle* p3 = new Circle(3); cout << "-------------------------------"<< endl; cout << "p1半径为" << p1->getRadius() << endl; cout << "p2半径为" << p2->getRadius() << endl; cout << "p3半径为" << p3->getRadius() << endl; cout << "-------------------------------"<< endl; //销毁p1 cout << "销毁对象p1" << endl; delete p1; //销毁p2 cout << "销毁对象p2" << endl; delete p2; //销毁p3 cout << "销毁对象p3" << endl; delete p3; return 0; }
运行结果：
由于我们调用的是缺省的拷贝构造函数，所以创建p2时，对象的个数没有加1。
还有一个问题是，我们调用的拷贝构造函数，是将p1的地址给了p2，还是新开辟了内存？
更改一下main.cpp
#include <iostream> #include "Circle.h" using namespace std; int main() { //调用无参构造函数 cout << "创建对象p1" << endl; Circle p1(2); //调用拷贝构造函数 cout << "创建对象p2" << endl; Circle p2(p1); //调用有参构造函数，参数为3 cout << "创建对象p3" << endl; Circle p3(3); cout << "-------------------------------"<< endl; cout << "p1半径为" << p1.getRadius() << endl; cout << "p1地址为" << &p1 << endl; //销毁p1 cout << "销毁对象p1" << endl; delete &p1; cout << "-------------------------------"<< endl; cout << "p2半径为" << p2.getRadius() << endl; cout << "p2地址为" << &p2 << endl; //销毁p2 cout << "销毁对象p2" << endl; delete &p2; cout << "-------------------------------"<< endl; cout << "p3半径为" << p3.getRadius() << endl; //销毁p3 cout << "销毁对象p3" << endl; delete &p3; return 0; }
运行结果：
可以看到，p1和p2有着两个不同的地址，而且p1被delete之后，p2的值还在。所以，拷贝构造函数会新开辟内存空间。
自定义拷贝构造函数
接下来解决之前对象个数不一致的问题。为了能让我们的对象个数在拷贝构造时也变化，我们就要自定义一个拷贝构造函数。
首先在Circle.h的public下添加：
//拷贝构造函数 Circle (const Circle&);
然后在Circle.cpp中添加函数体：
//拷贝构造函数 Circle::Circle(const Circle& c) { this->radius = c.radius; objectNumber++; cout << "拷贝成功" << endl; cout << "当前对象的个数是" << objectNumber << endl; }
然后再次运行main.cpp（main.cpp不变）
OK，现在就符合实际情况了。
深拷贝和浅拷贝
之前我们说到的都是浅拷贝。也就是说，如果类中有一个指针变量，在拷贝时，指针变量的值不会改变。这时，两个虽然两个对象具有不同的地址，但是两个对象的指针却指向同一个地址。当一个对象被销毁时，它的指针指向的内存也会销毁。因此，另一个对象销毁时，就会产生错误。
由此引出深拷贝。即让指针不指向同一个地址，这时就一定要自定义拷贝构造函数，给新对象的指针分配内存了。
（顺便一提，浅拷贝构造函数相当于用=，也就是说Circle p2(p1)也可以写为Circle p2 = p1）
假设我的类中有一个指针p，下面是浅拷贝构造函数：
//浅拷贝构造函数 Circle::Circle(const Circle& c) { this->radius = c.radius; this->p = c.p; objectNumber++; cout << "拷贝成功" << endl; cout << "当前对象的个数是" << objectNumber << endl; }
此时，没有为新对象的指针分配内存
main.cpp如下：
#include <iostream> #include "Circle.h" using namespace std; int main() { //调用无参构造函数 cout << "创建对象p1" << endl; Circle p1(2); //调用有参构造函数，参数为1 cout << "创建对象p2" << endl; Circle p2(p1); cout << "-------------------------------"<< endl; cout << "p1的指针p的值为" << p1.p << endl; cout << "-------------------------------"<< endl; cout << "p2的指针p的值为" << p2.p << endl; return 0; }
运行结果：
可以看到，两个指针的值都是0x82a978
再看深拷贝的拷贝构造函数：
//深拷贝构造函数 Circle::Circle(const Circle& c) { this->radius = c.radius; //先开辟内存 this->p = new int; //再赋值 *p = *(c.p); objectNumber++; cout << "拷贝成功" << endl; cout << "当前对象的个数是" << objectNumber << endl; }
main.cpp同上
运行结果：
此时两个指针指向的就是不同的地址了。