构造函数之二：构造函数常见的使用方式

原文地址：http://blog.csdn.net/jefry_xdz/article/details/7935760

觉得很好，就拿来参考了~

1、拷贝构造函数：

  模型:  

[cpp]  view plain  copy

1. class A   
2.   {  
3.      public :  
4.     A(A& a){  
5.       //函数体  
6.     }  
7.   };  

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

2、组合类构造函数

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

[cpp]  view plain  copy

1. class Base   
2. {  
3. private:  
4.     int b1;  
5.     int b2;  
6. public:  
7.     Base(int b1,int b2)  
8.     {  
9.        printf("base create \n");  
10.        this->b1 = b1;  
11.        this->b2 = b2;  
12.     }  
13.     ~Base()   
14.     {  
15.         printf("base destroy \n");   
16.     }  
17. };  
18.   
19.   
20. class Test  
21. {  
22. private:  
23.     int t1;  
24.     Base b;  
25. public:  
26.     Test(int b1,int b2,int t1):b(b1,b2)  
27.     {  
28.         printf("test create \n");  
29.         this->t1 = t1;  
30.     }  
31.     ~Test()  
32.     {  
33.        printf("test destroy \n");  
34.     }  
35. };  
36.   
37.   
38.   
39.   
40. int _tmain(int argc, _TCHAR* argv[])  
41. {  
42.     Test* test = new Test(1,2,3);  
43.       
44.     delete test;  
45.   
46.   
47.     int in;  
48.     scanf("&d",in);  
49. }  

结果：
base create
test create
test destroy

base destroy

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

[cpp]  view plain  copy

1. #include "stdafx.h"  
2. #include <iostream>  
3. using namespace std;  
4.   
5.   
6. class Base   
7. {  
8. private:  
9.     int b1;  
10.     int b2;  
11. public:  
12.     Base(int b1,int b2)  
13.     {  
14.        printf("base create \n");  
15.        this->b1 = b1;  
16.        this->b2 = b2;  
17.     }  
18.        
19.     Base(Base & b)   
20.     {  
21.         printf("copy create\n");  
22.     }  
23.   
24.   
25.     ~Base()   
26.     {  
27.         printf("base destroy \n");   
28.     }  
29. };  
30.   
31.   
32. class Test  
33. {  
34. private:  
35.     int t1;  
36.     Base b;  
37. public:  
38.     Test(Base b1,int t1):b(b1)  
39.     {  
40.         printf("test create \n");  
41.         this->t1 = t1;  
42.     }  
43.     ~Test()  
44.     {  
45.        printf("test destroy \n");  
46.     }  
47. };  
48.   
49.   
50.   
51.   
52. int _tmain(int argc, _TCHAR* argv[])  
53. {  
54.     Base b(1,2);  
55.     Test* test = new Test(b,3);  
56.       
57.     delete test;  
58.   
59.   
60.     int in;  
61.     scanf("&d",in);  
62. }  

结果：
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)
 {
}

我就不举例了，太多了