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; 这个才是在做等号运算。