C++构造与析构

　　构造函数中调用虚函数
　　调用的是基类中的函数不是调用派生类的，因为派生类还未构造完成。保持构造函数精简，可以把一些操作抽出来放在成员函数中，一般不要在构造函数中调用虚函数。

　　调用基类构造函数，需要放在初始化列表中，放在派生类函数体里就会调用两次基类的构造函数，第一次是编译器插入的调用基类的无参构造函数。

　　构造函数与析构函数调用顺序相反，大概是因为，派生类可能使用基类的数据

　　虚析构函数，当使用基类指针析构派生类对象时，保证调用正确的析构函数

下面给出一段测试代码：

  
    

   
      1 
   
     class
   
      A{

   
      2 
   
      
   
     public
   
     :

   
      3 
   
      A(){

   
      4 
   
      printf(
   
     "
   
     构造 A\n
   
     "
   
     );

   
      5 
   
      f();

   
      6 
   
      }

   
      7 
   
      
   
     virtual
   
      
   
     void
   
      f(){

   
      8 
   
      printf(
   
     "
   
     A.f()\n
   
     "
   
     );

   
      9 
   
      }

   
     10 
   
      
   
     virtual
   
      
   
     ~
   
     A(){

   
     11 
   
      printf(
   
     "
   
     析构 A\n
   
     "
   
     );

   
     12 
   
      }

   
     13 
   
     };

   
     14 
   
     

   
     15 
   
      
   
     class
   
      B: 
   
     public
   
      A{

   
     16 
   
      
   
     public
   
     :

   
     17 
   
      B(): A(){

   
     18 
   
      printf(
   
     "
   
     构造 B\n
   
     "
   
     );

   
     19 
   
      f();

   
     20 
   
      }

   
     21 
   
      
   
     virtual
   
      
   
     void
   
      f(){

   
     22 
   
      printf(
   
     "
   
     B.f()\n
   
     "
   
     );

   
     23 
   
      }

   
     24 
   
      
   
     virtual
   
      
   
     ~
   
     B(){

   
     25 
   
      printf(
   
     "
   
     析构 B\n
   
     "
   
     );

   
     26 
   
      }

   
     27 
   
     };

   
     28 
   
     

   
     29 
   
      
   
     int
   
      main(){

   
     30 
   
      A 
   
     *
   
     p 
   
     =
   
      
   
     new
   
      B();

   
     31 
   
      p
   
     ->
   
     f();

   
     32 
   
      delete p;

   
     33 
   
      
   
     return
   
      
   
     0
   
     ;

   
     34 
   
     }
  
    

运行结果：

  
    

   
     [lym@localhost tmp]
   
     $
   
      
   
     ./
   
     a
   
     .
   
     out
构造 A
A
   
     .
   
     f
   
     ()
   
     
构造 B
B
   
     .
   
     f
   
     ()
   
     
B
   
     .
   
     f
   
     ()
   
     
析构 B
析构 A
   
      
  
    

上面所说的几点，应该都可以看出来。

另外：

定义变量时，对于单参构造函数

Foo apple = 8; 与 Foo apple(8); 是等价的。