关于C++的构造函数, 复制构造函数 和 operator =

1.构造函数

　　 构造函数的定义我就不说了,我想说的只有一点,看下面的例子:

　　class C1

　　{

　　public:

　　//数据成员

　　int m_n;

　　//构造函数

　　C1(int n = 0)

　　{

　　 cout << "C1::C1()" << endl;

　　 m_n = n;

　　}

　　};

　　int _tmain(int argc, _TCHAR* argv[])

　　{

　　C1 o(10);//1.调用构造函数

　　C1 o1 = 10;//2.同样可以通过编译,也是调用了构造函数

　　C1 o2;//3

　　o2 = 10;//4.调用构造函数,生产临时对象,再赋值给o2

　　return 0;

　　}

　　 标1的地方很容易理解,直接调用构造函数,把10作为参数传递,但标2的地方多少有点费解了.把一个int 赋值给C1对象o2吗?不!看是一个赋值(=)实际上是初始化,也会调用构造函数(前提是存在适当形式的构造函数,比如上面,只有一个int参数,而=号右边的10也是一个int);

　　 标4的地方同样调用了构造函数,把10传递给了构造函数,生产了一个临时对象,然后把这个临时对象赋值给了o2(这里要调用 operator =(),如果有的话)

　　 不过看起来似乎有点别扭,我声明了一个C1的对象o1,却给了它一个int型的初始值.并且有时候这样的"转换"是危险的,需要避免(比如STL里面就有许多这样的例子),那就需要explicit关键字:

　　把构造函数改为这样:

　　//构造函数

　　explicit C1(int n = 0)

　　{

　　cout << "C1::C1()" << endl;

　　m_n = n;

　　}

　　再去编译上面的代码,编译器就会报错了.我们成功阻止了不受欢迎的转换. :)

　　2.复制构造函数

　　复制构造函数的原型是这样的:

　　T(const T& src)

　　具体到上面的类就是

　　//复制构造函数

　　C1(const C1& src)

　　{

　　cout << "Copy constructor" << endl;

　　m_n = src.m_n;

　　}

　　当然,这个类很简单,实际上根本不用再定义复制构造函数,系统默认的bitwise copy就够了.

　　//一个函数,返回C1类型

　　C1 f1()

　　{

　　C1 cTemp(10);//*

　　return cTemp;

　　}

　　int _tmain(int argc, _TCHAR* argv[])

　　{

　　C1 n = f1();//这里就是调用了复制构造函数

　　return 0;

　　}

　　注意:这个过程分别调用了一次构造函数(标*的地方),一次复制构造函数,如果把f1()里面改为:

　　return C1(10);

　　的话,就可以节省一次复制构造函数的调用了(相当于直接定义 C1 n(10)).

　　3.operator =

　　这个就比较简单了

　　C1& operator = (const C1& r)

　　{

　　if(&r == this) return *this;//防止自身赋值

　　m_n = r.m_n;

　　return *this;//支持连续赋值

　　}

　　如果定义了这个成员函数,在进行如下赋值操作时,就会调用该函数:

　　n2 = n1;//n2,n1都是C1类型的对象

　　当然你还可以定义其他参数类型的operator =()函数,以支持把其他类型的对象赋值给C1的对象.

　　需要说明的是,

　　n2 = n1;//n2,n1都是C1类型的对象

　　调用的是operator = 而不是 赋值构造函数 !

先来代码：

#include <iostream>

using namespace std;

class CA

{

public:

CA(int b)

{

cout << "constructure" << endl;

a=b;

}

CA(const CA& C) // 拷贝构造函数

//必须传引用，如果传值，就会要求构造临时对象，需要调用拷贝构造，又传值，又调用拷贝构造。。。

{

cout << "copy constructure" << endl;

a=C.a;

}

CA& operator=(const CA& C)//重写operator=

{

cout << "operator =" << endl;

a = C.a;

return *this;

}

void Show()

{

cout<<a<<endl;

}

private:

int a;

};

//下面这个函数是调用拷贝构造函数的一种情况

void pass_value(CA c)

{

cout << "in pass_value" << endl;

return;

}

int main()

{

CA A(100);

CA B(A); //拷贝构造

CA C = B;//拷贝构造

B = A;// operator=

pass_value(A); // 这个时候 因为是传值的，所以也会调用到拷贝构造函数

return 0;

}

1.拷贝构造函数，就是构造函数的一种特殊形式。其传入的参数是同类型的一个引用。

2.operator=重写=运算。其形式也有一定的特殊性。

3. 再来看，使用的情况。

CA B(A); 这是一个显示的构造函数的情况。

CA C=B; 这个看上去像是一个等号运算，但是实际上因为此时是要新建一个对象。所以仍然调用的是拷贝构造。

B =A; 这个才是在做等号运算。