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

来源：互联网发布：图片加文字软件编辑：程序博客网时间：2024/06/04 18:50

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

注意：

    (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

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/kanjunbao/archive/2009/11/13/4809139.aspx