构造函数，默认构造函数，复制构造函数，赋值构造函数

     构造函数、复制构造函数和赋值操作符在生成对象和对象之间的复制时用到。如果类中没有显式定义这三种函数，那编译器通常会为我们定义(合成)。如果类中定义了一个带参数的构造函数，那么编译器就不会再自动合成默认构造函数(空参数的构造函数)，这需要我们显式定义。

#include <iostream>
using namespace std;
class classA
{
public:
classA()      //默认构造函数
{
}
classA(int a)      //带参数的构造函数
{
}
classA(const classA& ma)       //复制构造函数
{
}
classA &operator=(const classA& ma)      //赋值操作符
{

   this->num = ma.num;

   return *this;
}
~classA()      //析构函数
{
}
void print()      //成员函数
{
}
private:
int num;       //数据成员
};

int main()
{
classA obj1;                   /*语句1，调用默认构造函数classA()*/

classA obj2(1);                /*语句2，调用构造函数classA(int a)*/

classA *pobj3 = new classA;    /*语句3，调用默认构造函数classA()，对象空间分配在堆中，要调用delete操作才能清除指针pobj3指向的classA对象空间.*/

classA(2);                     /*语句4，这个操作会建立一个无名的classA对象，调用构造函数classA(int a)*/

classA obj4(obj2);            /*语句5，调用复制构造函数classA(const classA& ma)，直接初始化形式，将对象obj2对象复制给obj4。复制构造函数可以理解为两步：先构造对象，然后进行复制操作。*/

classA obj5 = obj2;           /*语句6，调用复制构造函数classA(const classA& ma)的另一种是用形式：复制初始化，将对象obj2对象复制给obj5。*/

classA obj6 = classA(3);      /*语句7, 按照4语句和6语句的理解，似乎是先调用构造函数classA(int a)生成一个临时对象，然后再调用复制构造函数来初始化obj6，但实际编译的时候并不是这样的。这里只调用构造函数classA(int a)生成一个对象，把对象命名为obj6，等同于classA obj6(3)。既然新生成的对象已经符合语句的要求，那么把这个新对象命名为obj6就行。如果先生成一个临时对象，然后再调用复制构造函数，那就相当于生成了两个对象(临时对象和obj6对象)，进行一次复制操作，以及自动对临时对象进行析构操作(撤销临时对象)，效率低很多。*/

classA obj7 = classA(obj2);      /*语句8, 注意和语句7的区别。传入的实参是一个对象，从重载函数的角度去理解，这里是调用复制构造函数classA(const classA& ma)，等同于classA obj7(obj2)。*/

obj1 = obj2;               /*语句9, 对象obj1和obj2已经定义，即已经分配对象空间，那么这条语句调用的只是复制操作，并不会生成新的对象空间，调用赋值操作符classA &operator=(const classA& ma)。*/

obj1 = classA(obj2);       /*语句10，注意和语句9的区别。class(class object)的调用会生成一个新的对象空间。这里先调用复制构造函数classA(const classA& ma)，生成一个与obj2一样的临时对象，然后再调用赋值操作符classA &operator=(const classA& ma)将临时对象的内容复制给obj1。对比语句9，其操作过程不同，但效果等同。*/

obj1 = classA(6);        /*语句11，先调用构造函数classA(int a)产生一个临时对象，然后用调用赋值操作符classA &operator=(const classA& ma)，将临时对象复制给obj1，与语句7的区别是：生成的临时对象并不是直接命名为obj1(obj1已经定义)，而是将临时对象赋复制给obj1，然后再撤销临时对象。*/

classA obj8 = 8;          /*语句12，把一个整型复制给一个对象，会产生隐式的类类型转换。语句通过编译，需要在类中预先定义一个单形参的类型为int的构造函数，即classA(int a)，而且该函数不能用explicit修饰(阻止隐式转换)。这里会先调用构造函数classA(8)产生一个临时对象，然后把临时对象改名为obj8，并不会调用复制构造函数，原因见语句7。*/

obj8 = 9;        /*语句13，先调用构造函数classA(9)产生一个临时对象，然后用调用赋值操作符classA &operator=(const classA& ma)，将临时对象复制给obj8，等同于obj8 = classA(9)。*/

return 0;
}

    总结：定义一个类类型的对象，总会使用构造函数生成一个对象的空间。调用哪种构造函数(默认构造函数、带参数的构造函数和复制构造函数)根据传入的实参决定。空参数就调用默认构造函数(如语句1)，单个本类类型参数的就调用复制构造函数(如语句5)，其它参数形式调用对应的类中定义的构造函数(如语句2)。如果对象已经存在，两个对象之间的赋值操作调用的是赋值操作符(如语句9)。