拷贝构造函数:
定义:
如果一个构造函数的第一个参数是自身类类型的引用,且任何额外参数都有默认值,则此构造函数是拷贝构造函数。
典型的拷贝构造函数:
class Foo{
public:
Foo(){}; //默认构造函数
Foo(const Foo& f){}; //默认拷贝构造函数
}
拷贝构造函数的第一个参数必须是引用类型,虽然可以定义一个接收非const引用的拷贝构造函数,但此参数几乎总是一个const的引用。
何时使用拷贝构造函数:
(1)拷贝初始化(用=定义变量)
(2)将一个对象作为实参传递给非引用类型的形参
(3)一个返回类型为非引用类型的函数返回一个对象
示例题目:
假如Point是一个类类型,它有一个public的拷贝构造函数,指出下面程序片段中哪些地方使用了拷贝构造函数;
Point global;
Point func(Point p)
{
Point local = p,*heap = new Point(global);
*heap = local;
Point pa[4] = {local,*heap};
return *heap;
}
解答:
(1)local = p,将p拷贝给local
(2)*heap = local,将local拷贝给heap指定的地址
(3)Point pa[4] = {local,*heap}; ,将local和*heap拷贝给数组的前两位元素
(4)return *heap;
示例代码:
#include <iostream>
#include <string>
using namespace std;
static int objectCount = 0; //全局变量存储对象数量
class HowMany {
public :
HowMany() { objectCount++; print("HowMany()"); } //默认构造函数,并输出
void print(const string& msg = "") {
if (msg.size() != 0) cout << msg << ": "; //输出string类型参数
cout << "ObjectCount:" << objectCount << endl; //输出全局变量
}
~HowMany() { //析构函数
objectCount--;
print("~HowMany()");
}
};
HowMany f(HowMany x) {
cout << "Begin of f " << endl;
x.print("x argument inside of f()");
cout << "End of f" << endl;
return x;
}
int main()
{
HowMany h;
h.print("After construction of h");
HowMany h2 = f(h);
h.print("After call of f()");
return 0;
}
输出结果:
HowMany() : ObjectCount:1 //h构造 count++
After construction of h : ObjectCount:1 //h调用print函数,count == 1
Begin of f
x argument inside of f() : ObjectCount : 1 //参数x没有调用构造函数,count未变
End of f
~HowMany() : ObjectCount : 0 //f函数结束后,却析构了x,count--
After call of f() : ObjectCount : 0
~HowMany() : ObjectCount : -1 //h析构
~HowMany() : ObjectCount : -2 //h2析构
可以发现:f函数在调用HowMany类型参数x时,没有显性的调用构造函数,所以objectCount没有++,但却析构了x,objectCount--,导致最终结果的Count并没有归零
现在修改示例代码的HowMany类:
class HowMany {
public :
HowMany() { objectCount++; print("HowMany()"); }
HowMany(const HowMany& h) { objectCount++; print("HowMany(h)"); } //新的拷贝构造函数
void print(const string& msg = "") {
if (msg.size() != 0) cout << msg << ": ";
cout << "ObjectCount:" << objectCount << endl;
}
~HowMany() { //析构函数
objectCount--;
print("~HowMany()");
}
};
运行后结果:
HowMany(): ObjectCount:1 //h调用构造
After construction of h: ObjectCount:1
HowMany(h): ObjectCount:2 //f函数参数x调用构造
Begin of f
x argument inside of f(): ObjectCount:2
End of f
HowMany(h): ObjectCount:3 //h2调用构造
~HowMany(): ObjectCount:2
After call of f(): ObjectCount:2
~HowMany(): ObjectCount:1
~HowMany(): ObjectCount:0
此时,h,h2,和参数x分别调用了我们所写构造函数,增加了count,并在最后析构了自身。
在C++中,如果没有写默认的拷贝构造函数,编译器会自动调用默认的拷贝构造函数,默认的拷贝构造函数会作成员变量的拷贝,拷贝对应的类型来构造,并递归的进行下去。所以如果构造函数的参数不是引用类型,此时构造函数会无限循环,所以拷贝构造函数的第一个参数必须是引用类型。