形式多样的构造函数

1、拷贝构造函数：

  模型:  

  class A     {       public :      A(A& a){        //函数体      }    };

什么时候调用拷贝构造函数：
(1) 当用类的一个对象去初始化该类的另一个对象时候。系统
自动调用它实现拷贝赋值
  形如： A a(1,1); A b(a);
(2) 若函数的形参为类的对象，调用函数时，实参赋值形参，系统自动
调用拷贝函数.
        test(A a);       A aa; test(aa);

2、组合类构造函数

 模型：
  类::类(对象成员所需的形参，本类成员形参)：对象1(参数)，对象2(参数)，……{
  本类初始化
 }
 调用顺序：
     先调用内嵌对象的的构造函数，先声明的先调用。如果是缺省构造函数，则内嵌对象的初始化也将调用相应的缺省构造函数，析构相反。
 举例：

class Base {private:int b1;int b2;public:Base(int b1,int b2){   printf("base create \n");   this->b1 = b1;   this->b2 = b2;}~Base() {        printf("base destroy \n"); }};class Test{private:int t1;Base b;public:Test(int b1,int b2,int t1):b(b1,b2){        printf("test create \n");this->t1 = t1;}~Test(){       printf("test destroy \n");}};int _tmain(int argc, _TCHAR* argv[]){Test* test = new Test(1,2,3);delete test;int in;scanf("&d",in);}

结果：
base create
test create
test destroy

base destroy

例子：拷贝构造函数与组合类构造函数混用

#include "stdafx.h"#include <iostream>using namespace std;class Base {private:int b1;int b2;public:Base(int b1,int b2){   printf("base create \n");   this->b1 = b1;   this->b2 = b2;}     Base(Base & b) {printf("copy create\n");}~Base() {        printf("base destroy \n"); }};class Test{private:int t1;Base b;public:Test(Base b1,int t1):b(b1){        printf("test create \n");this->t1 = t1;}~Test(){       printf("test destroy \n");}};int _tmain(int argc, _TCHAR* argv[]){Base b(1,2);Test* test = new Test(b,3);delete test;int in;scanf("&d",in);}

结果：
base create
copy create
copy create
test create
base destroy
test destroy
base destroy

3、含有继承关系的构造函数

模型：
派生类：派生类(基类1新参,基类2新参，基类3形参，……，基类n新参，本类新参):
基类1(参数),基类2(参数)，……基类n(参数)，对象数据成员初始化 
{
  本类成员初始化赋值语句;

};

实例：

C(int a,int b,int c,int d):
B1(a),memberB2(d),memberB1(c),B2(b)
 {
}

我就不举例了，太多了