C++基础之overload/override/redefine

overload重载；override重写/覆盖；redefine重定义/隐藏

一、重载（overload）
    指函数名相同，但是它的参数表列个数或顺序，类型不同。并且不能靠返回类型来判断。
（1）相同的范围（在同一个作用域中） ；
（2）函数名字相同；
（3）参数不同；
（4）virtual关键字可有可无。
（5）返回值可以不同；

二、重写（也称为覆盖override）
    是指派生类重新定义基类的虚函数，特征是：
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字，不能有static 。
（5）返回值相同（或是协变），否则报错；

（6）重写函数的访问修饰符可以不同。尽管virtual 是private 的，派生类中重写改写为public, protected 也是可以的

三、重定义（也成隐藏）
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）返回值可以不同；
（4）参数不同。此时，不论有无virtual 关键字，声明为派生类，调用时基类的函数将被隐藏（注意别与重载以及覆盖混淆） 。

（5）参数相同，但是基类函数没有virtual关键字，声明为派生类，调用时基类的函数被隐藏（注意别与覆盖混淆） 。

 

综上：函数调用看声明，谁声明调用谁，但要解决 (1) 基类调用派生类的问题：基类声明virtual，派生类与基类的函数名和参数相同时，基类可以调用派生类的函数，重写的概念；(2) 派生类调用基类的问题：只要函数名相同，都调用派生类。

 

#include <iostream>
#include <complex>

using namespace std;

class Base
{
public:
    Base() { cout << "Base()" << endl; }
    virtual ~Base() { cout << "~Base()" << endl; }
    virtual void a(int x) { cout << "Base::a(int)" << endl; }
    // overload
    virtual void a(double x) { cout << "Base::a(double)" << endl; }
    virtual void b(int x) { cout << "Base::b(int)" << endl; }
    void c(int x) { cout << "Base::c(int) "<< x << endl; }
};

class Derived : public Base
{
public:
    Derived() { cout << "Derived()" << endl; }
    ~Derived() { cout << "~Derived()" << endl; }
    // redefine
    void a(complex<double> x) { cout << "Derived::a(complex)" << endl; }
    // override : base class must use "virtual"
    void b(int x) { cout << "Derived::b(int)" << endl; }
    // redefine 
    void c(int x) { cout << "Derived::c(int)" << endl; }
    void c(double x) { cout << "Derived::c(double)" << endl; }
};

int main()
{
    {
        Base m;
        m.a(1);
        m.a(1.1);
        m.b(10);
        m.c(2);
    }
    cout << "-----------------" << endl;
    {
        Derived m;
        m.a(1);
        m.a(1.1);
        m.b(10);
        m.c(2);
    }
    cout << "-----------------" << endl;
    {
        Base* pb = new Derived;
        pb->a(1);
        pb->a(1.1);
        pb->b(10);
        pb->c(2);
        pb->c(2.1);
        delete pb;
    }

    return 0;
}
/*
Base()
Base::a(int)
Base::a(double)
Base::b(int)
Base::c(int)
~Base()
-----------------
Base()
Derived()
Derived::a(complex)
Derived::a(complex)
Derived::b(int)
Derived::c(int)
~Derived()
~Base()
-----------------
Base()
Derived()
Base::a(int)
Base::a(double)
Derived::b(int)
Base::c(int)
Base::c(int)
~Derived()
~Base()
*/

#include <iostream>
#include <complex>

using namespace std;

class Base
{
public:
    Base() { cout << "Base()" << endl; }
    virtual ~Base() { cout << "~Base()" << endl; }
    void f() { b(1); c(1); d(1); e(1); }
//private:
    virtual void b(int x) { cout << "Base::b(int)" << endl; }
    virtual void c(int x) { cout << "Base::c(int)" << endl; }
    void d(int x) { cout << "Base::d(int)" << endl; }
    void e(int x) { cout << "Base::e(int)" << endl; }
};

class Derived : public Base
{
public:
    Derived() { cout << "Derived()" << endl; }
    ~Derived() { cout << "~Derived()" << endl; }
    void f() { b(1); c(1); d(1); e(1); }
    void b(int x) { cout << "Derived::b(int)" << endl; }
    void c(double x) { cout << "Derived::c(int)" << endl; }
    void d(int x) { cout << "Derived::d(int)" << endl; }
    void e(double x) { cout << "Derived::e(int)" << endl; }
};

int main()
{
    {
        Base m;
        m.f();
    }
    cout << "-----------------" << endl;
    {
        Derived m;
        m.f();
    }
    cout << "-----------------" << endl;
    {
        Base* pb = new Derived;
        pb->f();
        delete pb;
    }
    getchar();
    return 0;
}
/*
Base()
Base::b(int)
Base::c(int)
Base::d(int)
Base::e(int)
~Base()
-----------------
Base()
Derived()
Derived::b(int)
Derived::c(int)
Derived::d(int)
Derived::e(int)
~Derived()
~Base()
-----------------
Base()
Derived()
Derived::b(int)
Base::c(int)
Base::d(int)
Base::e(int)
~Derived()
~Base()
*/

 

virtual ~Base() 必须添加virtual，防止内存泄漏，若不加则子类不会进行析构。

class base
{
public:
    virtual fun() = 0; //0标志一个虚函数为纯虚函数  
}