首先说一下一个C++的空类，编译器会加入哪些默认的成员函数

(1)默认构造函数

(2)拷贝构造函数

(3)析构函数

(4)赋值函数（赋值运算符）

以上四个函数是只声明一个空类而不去使用时，编译器会默认生成

即使程序没定义任何成员，编译器也会插入以上的函数！

(5)取值函数 (取地址运算符)

(6)取值函数 (取值运算符const)

以上两个函数是使用时生成

1.构造函数

构造函数是一种特殊的类成员函数，是当创建一个类的对象时，它被调用来对类的数据成员进行初始化和分配内存。（构造函数的命名必须和类名完全相同）

注意：构造函数可以被重载，可以多个，可以带参数；析构函数只有一个，不能被重载，不带参数，而默认构造函数没有参数，它什么也不做。当没有重载无参构造函数时，就是通过默认构造函数来创建一个对象。

下面代码为构造函数重载的实现

class A
{
int m_i;
Public:
A()
{
Cout<<”无参构造函数”<<endl;
}
A(int i):m_i(i) {} //初始化列表
}

2.拷贝构造函数

拷贝构造函数是C++独有的，它是一种特殊的构造函数，用基于同一类的一个对象构造和初始化另一个对象。

当没有重载拷贝构造函数时，通过默认拷贝构造函数来创建一个对象

A a;

A b(a);

A b=a; 都是拷贝构造函数来创建对象b

强调：这里b对象是不存在的，是用a 对象来构造和初始化b的

先说下什么时候拷贝构造函数会被调用：

在C++中，3种对象需要复制，此时拷贝构造函数会被调用

1）一个对象以值传递的方式传入函数体

2）一个对象以值传递的方式从函数返回

3）一个对象需要通过另一个对象进行初始化

什么时候编译器会生成默认的拷贝构造函数：

1）如果用户没有自定义拷贝构造函数，并且在代码中使用到了拷贝构造函数，编译器就会生成默认的拷贝构造函数。但如果用户定义了拷贝构造函数，编译器就不在生成。

2）如果用户定义了一个构造函数，但不是拷贝构造函数，而此时代码中又用到了拷贝构造函数，那编译器也会生成默认的拷贝构造函数。

因为系统提供的默认拷贝构造函数工作方式是内存拷贝，也就是浅拷贝。如果对象中用到了需要手动释放的对象，则会出现问题，这时就要手动重载拷贝构造函数，实现深拷贝。

下面说说深拷贝与浅拷贝：

浅拷贝：如果复制的对象中引用了一个外部内容（例如分配在堆上的数据），那么在复制这个对象的时候，让新旧两个对象指向同一个外部内容，就是浅拷贝。（指针虽然复制了，但所指向的空间内容并没有复制，而是由两个对象共用）

深拷贝：如果在复制这个对象的时候为新对象制作了外部对象的独立复制，就是深拷贝。

以上描述不详细，具体参见：http://www.cnblogs.com/liushui-sky/p/7728839.html

拷贝构造函数重载声明如下：

A (const A&other)

下面为拷贝构造函数的实现：

class A
{
int m_i
A(const A& other):m_i(other.m_i)
{
Cout<<”拷贝构造函数”<<endl;
}
}

3.赋值函数

当一个类的对象向该类的另一个对象赋值时，就会用到该类的赋值函数。

当没有重载赋值函数（赋值运算符）时，通过默认赋值函数来进行赋值操作

A a;

A b;

b=a;

强调：这里a,b对象是已经存在的，是用a 对象来赋值给b的

赋值运算的重载声明如下：

A& operator = (const A& other)

通常大家会对拷贝构造函数和赋值函数混淆，这儿仔细比较两者的区别：

1）拷贝构造函数是一个对象初始化一块内存区域，这块内存就是新对象的内存区，而赋值函数是对于一个已经被初始化的对象来进行赋值操作。

class A;
A a;
A b=a; //调用拷贝构造函数（b不存在）
A c(a) ; //调用拷贝构造函数
/****/
class A;
A a;
A b;
b = a ; //调用赋值函数(b存在)

2）一般来说在数据成员包含指针对象的时候，需要考虑两种不同的处理需求：一种是复制指针对象，另一种是引用指针对象。拷贝构造函数大多数情况下是复制，而赋值函数是引用对象

3）实现不一样。拷贝构造函数首先是一个构造函数，它调用时候是通过参数的对象初始化产生一个对象。赋值函数则是把一个新的对象赋值给一个原有的对象，所以如果原来的对象中有内存分配要先把内存释放掉，而且还要检察一下两个对象是不是同一个对象，如果是，不做任何操作，直接返回。（这些要点会在下面的String实现代码中体现）

如果不想写拷贝构造函数和赋值函数，又不允许别人使用编译器生成的缺省函数，最简单的办法是将拷贝构造函数和赋值函数声明为私有函数，不用编写代码。如：

class A
{
private:
A(const A& a); //私有拷贝构造函数
A& operate=(const A& a); //私有赋值函数
}

如果程序这样写就会出错：

A a;
A b(a); //调用了私有拷贝构造函数，编译出错
A b;
b=a; //调用了私有赋值函数，编译出错

所以如果类定义中有指针或引用变量或对象，为了避免潜在错误，最好重载拷贝构造函数和赋值函数。

4.取值函数

class A
{
int m_i ;
A(const A& other):m_i(other.m_i)
{
Cout<<”拷贝构造函数”<<endl;
}
}

A a;

A *b = &a;//调用取值函数

5.取值函数（const）

class A
{
int m_i ;
A(const A& other):m_i(other.m_i)
{
Cout<<”拷贝构造函数”<<endl;
}
}

const A a;

const A *b = &a;//调用const取值函数

6.析构函数

class A
{
int m_i;
Public:
A()
{
Cout<<”无参构造函数”<<endl;
}
~A()
{
Cout<<”析构函数”<<endl;
}
A(int i):m_i(i) {} //初始化列表
}

=========================================================================

#include <iostream>
class Complex {
public:
   Complex()
   {
       std::cout << "call construct func" << std::endl;
   } // 默认构造函数;
   Complex(const Complex&)
   {
       std::cout << "call copy construct func" << std::endl;
   } // 默认拷贝构造函数
   ~Complex()
   {
       std::cout << "call destroy construct func" << std::endl;
   } // 析构函数
   Complex& operator = (const Complex &plex)
   {
       std::cout << "call operator = func" << std::endl;
       sName = plex.sName;
       sCode = plex.sCode;
       return *this;
   }// 赋值运算符
   Complex *operator &()
   {
       std::cout << "call operator & func" << std::endl;
       return this;
   } // 取值运算符
   const Complex *operator &() const
   {
       std::cout << "call operator const & func" << std::endl;
       return this;
   } // 取值运算符const

private:
std::string sName;
std::string sCode;

};

int main()
{

   Complex c1;       //调用构造函数
   Complex c2(c1); //调用拷贝构造函数
   Complex c3 = c1; //调用拷贝构造函数
   Complex c4;           //调用构造函数
   c4 = c1; //调用赋值函数
   Complex *c5 = &c1; //调用取值函数
   const Complex c6;   //调用构造函数
   const Complex *c7 = &c6;//调用const取值函数
   return 0;
}