继承中多态和拷贝构造函数

 

http://www.cnblogs.com/JCSU/articles/1094064.html

 示例一：继承中多态和拷贝构造函数

注  意：

    (1) 每个类只能有一个析构函数。析构时，拷贝构造函数也会被析构。
    (2) 析构与构造的顺序正好相反。
    (3) 如果类中显式定义了拷贝构造函数和赋值函数，系统就不会使用默认的拷贝构造函数和赋值函数。
    (4) 如果基类中定义了虚函数，当使用指向基类的指针访问派生类时会产生动态绑定，产生多态现象。当删除该基指针时，会调用基类的析构函数。
    (5) 注意拷贝构造函数与赋值函数的被调用场合。

    以下程序的运行结果中，黄底的构造函数个数与橙底的析构造函数个数相等，构造与析构顺序相反

/**/ /*
 * 1. 面向对象编程的关键思想是多态性
 * 2. 在C++中，基类必须指出希望派生类重新定义哪些函数，定义为virtual的函数是基类期待派生类重新
 *    定义的，基类希望派生类继承的函数不能定义为虚函数
 * 3. 通过动态绑定，能编写程序使用继承层次中任意类型的对象，无须关心对象的具体类型。使用这些类的
 *    程序无须区分函数是在基类还是在派生类中定义的
 * 4. 在C++中，通过基类的引用(或指针)调用虚函数时，发生动态绑定。引用(或指针)既可以指向基类对象
 *    也可以指向派生类对象。这一事实是动态绑定的关键。用引用(或指针)调用的虚函数在运行时确定，被
 *    调用的函数是引用(或指针)所指对象的实际类型所定义的
 * 5. 保留字virtual的目的是启用动态绑定
 * 6. 成员函数默认为非虚函数，对非虚函数的调用在编译时确定
 * 7. 派生类一般会重定义所继承的虚函数，如果派生类没有重定义某个虚函数，则使用基类中定义的版本
 * 8. 一旦函数在基类中声明为虚函数，它就一直为虚函数，派生类无法改变该函数为虚函数这一事实
 * 9. 要触发动态绑定，必须满足：一、将成员函数指定为虚函数，二、必须通过基类类型的引用或指针进行
 *    函数调用
 * 10. 如果调用非虚函数，则无论实际对象是什么类型，都执行基类类型所定义的函数
  */
#include   < iostream.h >

class  A
{
   public :
    A() {cout  <<   " A constructor/n " ;}
     ~ A() {cout  <<   " A destructor/n " ;}
    A( const  A  & a)  // 类A的拷贝构造函数
     {
        cout << " A's copy constructor /n " ;
    }
    A  &   operator = ( const  A  &  a)  // 赋值运算符
     {
        cout << " A's assignment operator! /n " ;
         return   * this ;
    }
     virtual   void  use() {cout  <<   " in A/n " ;}   // 将函数use()声明为虚函数
     void  book()  const   { cout  <<   " book in A/n " ; }   // book()为普通函数
 } ;

class  B: public  A
{
   public :
    B() {cout  <<   " B constructor/n " ;}
     ~ B() {cout  <<   " B destructor/n " ;}
     void  use() {cout  <<   " in B/n " ;}
     virtual   void  book()  const   { cout  <<   " book in B/n " ; }  
} ;

class  C: public  B
{
   public :
    C() {cout  <<   " C constructor/n " ;}
     ~ C() {cout  <<   " C destructor/n " ;}
     virtual   void  use() {cout  <<   " in C/n " ;}   // 关键字virtual此时可有在无
     void  book()  const   { cout  <<   " book in C/n " ; }  
} ;

void  main()
{
    B b1;
    A a1(b1);  // 调用拷贝构造函数
    cout << " -------------------------/n " ;

    B b2;
    A a2 = b2;  // 调用拷贝构造函数
    cout << " -------------------------/n " ;

    B b3;
    A a3;
    a3 = b3;  // 调用类的赋值运算
    cout << " -------------------------/n " ;

    A  * p;
    p = new  C;  // p points to an dynamically allocated, unnamed, uninitialized object

    p -> book();  // A中的book()方法不是虚方法, 无动态绑定功能
    p -> use();  // A中的use()方法为虚方法, 类B和类C中有无virtual都可以实现动态绑定
    cout << " -------------------------/n " ;

    delete p;   // object of type A destroyed

    cout << " -------------------------/n " ;
     // deconstructors
}

运行结果：
A constructor
B constructor
A's copy constructor
--------------------------
A constructor
B constructor
A's copy constructor
--------------------------
A constructor
B constructor
A constructor
A's assignment operator!
--------------------------
A constructor
B constructor
C constructor
book in A
in C
--------------------------
A destructor
--------------------------
A destructor
B destructor
A destructor
A destructor
B destructor
A destructor
A destructor
B destructor
A destructor


示例二：非继承中的多态

#include  < iostream.h >

class  A
{
   public :
     virtual   void  f() {cout  <<   " Function f in class A/n " ;}
     void  g() {cout  <<   " Function g in class A/n " ;}
} ;

class  B
{
public :
     virtual   void  f() {cout  <<   " Function f in class B/n " ;}
     void  g() {cout  <<   " Function g in class B/n " ;}
} ;

class  C
{
public :
     virtual   void  h() {cout  <<   " Function h in class C/n " ;}
} ;

void  main()
{
    A oa,  * p;
    B ob;
    C oc;

    p =& oa;
    p -> f();
    p -> g();

    p = (A  * ) & ob;
    p -> f();
    p -> g();

    p = (A  * ) & oc;
    p -> f();
    p -> g();
     // p->h();
}               

运行结果：
Function f in class A
Function g in class A
Function f in class B
Function g in class A
Function h in class C
Function g in class A