c++类的函数重载、重写示例

1、文件cls.h
头文件cls.h实现了基类Base1、Base2，和子类Derived1、Derived2。

#pragma once
#include <iostream>
using namespace std;

class Base1
{
public:
    Base1() { cout << "Constrution Base1" << endl; }
    //~Base1() { cout << "Destrution Base1" << endl; }

    virtual ~Base1() { cout << "Destrution Base1" << endl; }

    virtual void f() { cout << "Base1::f" << endl; }

    virtual void g() { cout << "Base1::g" << endl; }

    virtual void h() { cout << "Base1::h" << endl; }

    void func(){ cout << "Base1::func" << endl; }
};

class Base2
{
public:
    Base2() { cout << "Constrution Base2" << endl; }
    //~Base2() { cout << "Destrution Base2" << endl; }

    virtual ~Base2() { cout << "Destrution Base2" << endl; }

    virtual void f() { cout << "Base2::f" << endl; }

    virtual void g() { cout << "Base2::g" << endl; }

    virtual void h() { cout << "Base2::h" << endl; }

    void func() { }
};

class Derived1 :public Base1
{
public:
    Derived1() { cout << "Constrution Derived1" << endl; }
    ~Derived1() { cout << "Destrution Derived1" << endl; }

    virtual void f() { cout << "Derived1::f" << endl; }   // virtual可写可不写

    virtual void g1() { cout << "Derived1::g1" << endl; }

    virtual void h1() { cout << "Derived1::h1" << endl; }

    void func() { cout << "Derived1::func" << endl; }

};

class Derived2 :public Base2, public Base1
{
public:
    Derived2() { cout << "Constrution Derived2" << endl; }
    ~Derived2() { cout << "Destrution Derived2" << endl; }

    virtual void f()  { cout << "Derived2::f" << endl;  }

    virtual void g1() { cout << "Derived2::g1" << endl; }

    virtual void h1() { cout << "Derived2::h1" << endl; }
};

2、主函数
测试函数的派生、虚函数重写、重载等示例。

#include "cls.h"

int main()
{
    Base1 b1;
    Base2 b2;
    Derived1 d1;
    Derived2 d2;
    // 大小与函数列表有关
    cout << "sizeof(Base1) = " << sizeof(Base1) << " sizeof(b1) = " << sizeof(b1) << endl;
    cout << "sizeof(Base2) = " << sizeof(Base2) << " sizeof(b2) = " << sizeof(b2) << endl;
    cout << "sizeof(Derived1) = " << sizeof(Derived1) << " sizeof(d1) = " << sizeof(d1) << endl;
    cout << "sizeof(Derived2) = " << sizeof(Derived2) << " sizeof(d1) = " << sizeof(d1) << endl;

    Derived1 d;  // d 能直接调用Derived1的所有函数、Base1的非虚函数，间接调用base1的虚函数
    d.f();        // Derived::f
    d.g1();       // Derived::g1
    d.Base1::f(); // Base1::f 
    d.func();

    Derived1 *d = new Derived1(); // 同上
    d->f();          // Derived::f
    d->g1();         // Derived::g1
    d->Base1::f();   // Base1::f
    d->func();       // Derived1::func   重载
    d->Base1::func();// Base1::func      间接调用，显示调用

    Base1 *b = new Derived1(); // b 只能调用Base1的函数，但是虚函数会被动态绑定
    b->f();     // Derived1::f 
    b->g();     // Base1::g
    b->func();  // Base1::func

    Base1 *b = new Base1(); // 显然只能调用base1的函数
    b->f();   // Base1::f
    b->g();   // Base1::g
    b->func();// Base1::func


    Base1 *b = new Base1(); 
    delete b; // 不论基类析构函数是否为虚函数，都会执行函数体

    Base1 *b = new Derived1(); 
    delete b; // 当基类析构函数为虚时，才会析构父类;    否则，只执行基类的析构函数

    Derived1 *d = new Derived1();
    delete d;   // 不论基类析构函数是否为虚函数，都会执行函数体



    Derived2 d2;//直接调用Derived2的函数，间接调用父类函数
    d2.f();         // Derived2::f
    d2.Base1::f();  // Base1::f
    d2.Base2::f();  // Base2::f

    Derived2 *d2 = new Derived2();//直接调用Derived2的函数，间接调用父类函数
    d2->f();        // Derived2::f
    d2->Base1::f(); // Base1::f
    d2->Base2::f(); // Base2::f
    delete d2;

    Base1 *d2 = new Derived2();// 调用base1的函数和Derived2重写的函数，
    d2->f();            // 子类重写 Derived2::f
    d2->Base1::f();   // 间接调用父类虚函数 Base1::f    
    d2->g();            // 直接调用父类虚函数 Base1::g    
    d2->func();     // 直接调用父类非虚函数 Base1::func
    delete d2;        //其中一个父类析构函数必须为虚函数

    return 0;
}