析构、多态、拷贝构造和赋值[C++][code]

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

注  意：

    (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