C++重写（覆盖）、重载、重定义、多态

转载

Liuqz2009 2023-01-05 12:17:09 博主文章分类：C++

文章标签 派生类父类多态性 文章分类 运维

1 重写（覆盖）override

　　override是重写（覆盖）了一个方法，以实现不同的功能。一般用于子类在继承父类时，重写（覆盖）父类中的方法。函数特征相同，但是具体实现不同。

重写需要注意：

被重写的函数不能是static的，必须是virtual的
重写函数必须有相同的类型，名称和参数列表
重写函数的访问修饰符可以不同。尽管virtual是private的，派生类中重写改写为public、protect也是可以的

2 重载overload

　　overload是重载，一般是在一个类实现若干重载的方法，这些方法的名称相同而参数形式不同。但是不能靠返回类型来判断。

重载需要注意：

位于同一个类中
函数的名字必须相同
形参列表不同
若一个重载版本的函数面前有virtual修饰，则表示他是虚函数，但他也是属于重载的一个版本
不同的构造函数(无参构造、有参构造、拷贝构造）是重载的应用

3 重定义redefining

　　派生类对基类的成员函数重新定义，即派生类定义了某个函数，该函数的名字与基类中函数名字一样。

　　重定义也叫做隐藏，子类重定义父类中有相同名称的非虚函数（参数可以不同）。如果一个类，存在和父类相同的函数，那么这个类将会覆盖其父类的方法，除非你在调用的时候，强制转换为父类类型，否则试图对子类和父类做类似重载的调用时不能成功的。

重定义需要注意：

不在同一个作用域（分别位于基类、派生类）
函数的名字必须相同
对函数的返回值、形参列表无要求
若派生类定义该函数与基类的成员函数完全一样（返回值、形参列表均相同），且基类的该函数为virtual，则属于派生类重写基类的虚函数
若重新定义了基类中的一个重载函数，则在派生类中，基类中该名字函数（即其他所有重载版本）都会被自动隐藏，包括同名的虚函数

4 多态polymorphism

　　多态的概念比较复杂，一种不严谨的说法是：继承是子类使用父类的方法，而多态是父类使用子类的方法。

　　一般我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。

　　多态分为两类：静态多态性和动态多态性，以前学过的函数重载和运算符重载实现的多态性属于静态多态性，在程序编译时系统就能决定调用哪个函数，因此静态多态性又称为编译时的多态性。静态多态性是通过函数的重载实现的。动态多态性是在程序运行过程中才动态地确定操作所针对的对象。它又称运行时的多态性。动态多态性是通过虚函数实现的。

下面列举一个实例来说明他们：

#include <iostream>
using namespace std;

class Base
{
private:
    virtual void display() { std::cout << "Base display()" << endl; }

    void say() { cout << "Base say()" << endl; }

public:
    void exec()
    {
        display();
        say();
    }

    void fun1(string a)
    {
        cout << "Base fun1(string)" << endl;
    }

    void fun1(int a)
    {
        cout << "Base fun1(int)" << endl;
    } //overload，两个fun1函数在Base类的内部被重载
};

class ChildA : public Base
{

public:
    void display() { cout << "ChildA display()" << endl; } //override，基类中的display为虚函数，故此处为重写（覆盖）

    void fun1(int a, int b) { cout << "ChildA fun1(int,int)" << endl; } //redefining，fun1函数在Base类中不为虚函数，故此处为重定义

    void say() { cout << "ChildA say()" << endl; } //redefining
};

class ChildB : public Base
{

public:
    void fun1(int a) { cout << "ChildB fun1(int)" << endl; } //redefining
};

int main()

{
    ChildA a;

    Base *b = &a;

    b->exec(); //display():version of DeriveA call(polymorphism) //say():version of Base called(allways )

    //b里边的函数display被A类重写（覆盖），say还是自己的

    a.exec(); //same result as last statement
    a.say();
    DeriveB c;
    c.f1(1); //version of DeriveB called
}