C++ 构造函数和析构函数是否可以继承？

先看一个例子：

[cpp]  view plain copy

1. #include <iostream>  
2.   
3. class A  
4. {  
5. public:  
6.     A() { ::std::cout << "constructor: A" << ::std::endl; } // 构造函数不能为 virtual  
7.     A(int aa): a(aa) { ::std::cout << "constructor: A, a = " << a << ::std::endl; }  
8.     virtual ~A() { ::std::cout << "destructor: A" << ::std::endl; }  
9. public:  
10.     int a;  
11. };  
12.   
13. class B : public A  
14. {  
15. public:  
16.     B() { ::std::cout << "constructor: B" << ::std::endl; }  
17.     B(int bb) : b(bb) { ::std::cout << "constructor: B, b = " << b << ::std::endl; }  
18.     B(int aa, int bb): A(aa), b(bb) { ::std::cout << "constructor: B, a = " << a << ", b = " << b << ::std::endl; }  
19.     ~B() { ::std::cout << "destructor: B" << ::std::endl; }  
20. public:  
21.     int b;  
22. };  
23.   
24. class A2  
25. {  
26. public:  
27.     A2() { ::std::cout << "constructor: A2" << ::std::endl; }  
28.     explicit A2(int aa) { ::std::cout << "constructor: A2, aa = " << aa << ::std::endl; }  
29.     virtual ~A2() { ::std::cout << "destructor: A2" << ::std::endl; }  
30. };  
31.   
32. class B2: public A2  
33. {  
34. public:  
35.     using A2::A2;   // Inheriting constructors(VS2013 not support, GCC before version 4.8 not support)  
36.     ~B2() { ::std::cout << "destructor: B2" << ::std::endl; }  
37. };  
38.   
39. int main()  
40. {  
41.     B b_1;          // A() --> B() --> ~B() --> ~A() 隐式调用直接父类的无参构造函数  
42.     B b_2(22);      // A() --> B(int) --> ~B() --> ~A() 隐式调用直接父类的无参构造函数  
43.     B b_3(11, 22);  // A(int) --> B(int, int) --> ~B() --> ~A() 委托构造函数  
44.   
45.     // 其实这里调了 B2() 及 B2(int), 只不过没有输出而已  
46.     B2 b2_1;        // A2() --> B2() --> ~B2() --> ~A2()  
47.     B2 b2_2(11);    // A2(int) --> B(int) --> ~B2() --> ~A2()  
48.     return 0;  
49. }  
50. /* 
51. constructor: A 
52. constructor: B 
53. constructor: A 
54. constructor: B, b = 22 
55. constructor: A, a = 11 
56. constructor: B, a = 11, b = 22 
57. constructor: A2 
58. constructor: A2, aa = 11 
59. destructor: B2 
60. destructor: A2 
61. destructor: B2 
62. destructor: A2 
63. destructor: B 
64. destructor: A 
65. destructor: B 
66. destructor: A 
67. destructor: B 
68. destructor: A 
69. */  

结论：

1. 构造函数不能为 virtual, 构造函数不能继承；

2. 如果子类不显式调用父类的构造函数，编译器会自动调用父类的【无参构造函数】；

3. 继承构造函数（Inheriting constructors）

(1) C++11 才支持;

(2) 实质是编译器自动生成代码，通过调用父类构造函数来实现，不是真正意义上的【继承】，仅仅是为了减少代码书写量（参考 《C++ Primer》）。

FROM: http://blog.csdn.net/duyiwuer2009/article/details/41047609