C++ 多态：原理、实现与应用

引言

一、多态的概念

二、多态的定义及实现

（一）构成条件

[六、C++11 override 和 final](#六、C++11 override 和 final)

（一）final

（二）override

七、重载、覆盖（重写）、隐藏（重定义）的对比

引言

在 C++ 编程世界里，多态是一个强大且迷人的特性。它允许我们以统一的接口来处理不同类型的对象，实现 "一种接口，多种形态"。这不仅提升了代码的灵活性与可维护性，还极大地增强了程序的扩展性。今天，就让我们深入探究 C++ 多态的奥秘。

一、多态的概念

多态，通俗来讲，就是同一行为在不同对象上表现出不同的状态。就像现实生活中，买票这个行为，普通人买票是全价，学生买票是半价，军人买票可能有优先特权。在 C++ 中，多态使得我们可以用相同的函数调用，根据对象类型的不同执行不同的操作。

二、多态的定义及实现

（一）构成条件

虚函数：**被 virtual 关键字修饰的类成员函数。**例如：

cpp 复制代码

cpp

class Person {

public:

    virtual void BuyTicket() {

        std::cout << "买票 - 全价" << std::endl;

    }

};

虚函数覆盖：**派生类中定义与基类虚函数返回值类型、函数名字、参数列表完全相同的虚函数。**如：

cpp 复制代码

cpp

class Student : public Person {

public:

    virtual void BuyTicket() {

        std::cout << "买票 - 半价" << std::endl;

    }

};

1. 通过基类指针或引用调用虚函数：

###不可用子类 指针或引用调用虚函数（ - 使用父类指针或引用可以指向不同的子类对象，通过相同的父类接口来调用不同子类实现的方法，从而体现多态性。如果仅使用子类指针或引用，只能调用子类自身定义或重写的方法，无法通过统一的父类接口来实现多种不同的行为，也就无法充分体现多态的特性。）

###不可用父类对象（ 父类对象调用的方法是在父类中定义的方法，不会调用子类重写后的方法。多态的核心是根据对象的实际类型来决定调用哪个类中重写的方法，而父类对象的类型是固定的，不能根据不同的情况表现出不同的行为，无法体现多态性。）

cpp 复制代码

cpp

void Func(Person& people) {

    people.BuyTicket();

}



int main() {

    Person Mike;

    Student Johnson;



    Func(Mike);

    Func(Johnson);



    return 0;

}

在上述代码中， Func 函数通过基类 Person 的引用调用 BuyTicket 虚函数，根据传入对象是 Person 还是 Student ，会分别执行对应的 BuyTicket 函数版本，实现多态行为。

（二）虚函数的深入理解

虚函数是实现多态的关键。当类中包含虚函数时，编译器会为该类生成一个虚函数表（虚表）不同于继承，每个对象中会包含一个指向虚函数表的指针（ vptr ）。在调用虚函数时，程序通过对象的 vptr 找到虚函数表，再从表中获取对应函数的地址进行调用。

例如：

cpp 复制代码

cpp

class Base {

public:

    virtual void Func1() {

        std::cout << "Base::Func1" << std::endl;

    }

    virtual void Func2() {

        std::cout << "Base::Func2" << std::endl;

    }

private:

    int _b = 1;

};

对于包含虚函数的 Base 类对象，其大小除了成员变量占用的空间外，还会包含一个 vptr 的大小（通常在 32 位系统下为 4 字节，64 位系统下为 8 字节）。

（三）虚函数的重写（覆盖）

派生类重写基类虚函数时，需满足函数签名（返回值类型、函数名、参数列表）完全相同。不过存在两个例外：

协变：基类与派生类虚函数返回值类型不同，即基类虚函数返回基类对象的指针或引用，派生类虚函数返回派生类对象的指针或引用。例如：

cpp 复制代码

cpp

class A {};

class B : public A {};



class Person {

public:

    virtual A* f() {

        return new A;

    }

};



class Student : public Person {

public:

    virtual B* f() {

        return new B;

    }

};

析构函数的重写：如果基类的析构函数为虚函数，派生类析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写。尽管函数名不同（基类 ~Person ，派生类 ~Student ），但编译器会对析构函数名称做特殊处理，统一成 destructor。

cpp 复制代码

cpp

class Person {

public:

    virtual ~Person() {

        std::cout << "~Person()" << std::endl;

    }

};



class Student : public Person {

public:

    virtual ~Student() {

        std::cout << "~Student()" << std::endl;

    }

};

三、抽象类

（一）概念

包含纯虚函数（在虚函数声明后面加上 = 0 ）的类称为抽象类，也叫接口类。抽象类不能实例化对象，派生类继承抽象类后，只有重写纯虚函数才能实例化对象。纯虚函数规范了派生类必须实现的接口。

cpp 复制代码

cpp

class Car {

public:

    virtual void Drive() = 0;

};



class Benz : public Car {

public:

    virtual void Drive() {

        std::cout << "Benz - 舒适" << std::endl;

    }

};



class BMW : public Car {

public:

    virtual void Drive() {

        std::cout << "BMW - 操控" << std::endl;

    }

};



void Test() {

    Car* pBenz = new Benz;

    pBenz->Drive();



    Car* pBMW = new BMW;

    pBMW->Drive();

}

（二）接口继承和实现继承

普通函数的继承是实现继承，派生类继承基类函数的实现，可以直接使用函数。虚函数的继承是接口继承，派生类继承基类虚函数的接口，目的是为了重写以达成多态。所以如果不实现多态，就不要把函数定义成虚函数。

四、多态的原理

（一）虚函数表

当类中有虚函数时，编译器会为类创建虚函数表。以简单的单继承为例：

cpp 复制代码

cpp

class Base {

public:

    virtual void Func1() {

        std::cout << "Base::Func1" << std::endl;

    }

private:

    int _b = 1;

};



class Derive : public Base {

public:

    virtual void Func1() {

        std::cout << "Derive::Func1" << std::endl;

    }

private:

    int _d = 2;

};

在上述代码中， Base 类对象包含 vptr 和成员变量 _b ， Derive 类对象包含从 Base 继承的部分（ vptr 和 _b ）以及自身的成员变量 _d 。 Derive 重写了 Func1 ，其虚函数表中 Func1 的地址是 Derive::Func1 的地址，而从 Base 继承的虚函数（如还有其他未重写虚函数）会将基类虚函数表中的对应函数地址拷贝过来。

1.派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
6. 这里还有一个我们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？答：虚函数存在虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。

那么虚表存在哪里

答案是常量区

（二）动态绑定与静态绑定

静态绑定：又称前期绑定，在程序编译期间确定程序的行为，例如函数重载，编译时就能确定调用哪个函数版本。
动态绑定：又称后期绑定，在程序运行期间，根据具体对象的类型确定调用的具体函数，多态就是通过动态绑定实现的。

五、单继承和多继承关系中的虚函数表

（一）单继承中的虚函数表

cpp 复制代码

cpp

class Base {

public:

    virtual void func1() {std::cout << "Base::func1" << std::endl;}

    virtual void func2() {std::cout << "Base::func2" << std::endl;}

private:

    int _b;

};



class Derive : public Base {

public:

    virtual void func1() {std::cout << "Derive::func1" << std::endl;}

    virtual void func3() {std::cout << "Derive::func3" << std::endl;}

    virtual void func4() {std::cout << "Derive::func4" << std::endl;}

private:

    int _d;

};

在单继承中，派生类会拷贝基类虚函数表内容，并重写被覆盖的虚函数地址，新增的虚函数按声明顺序添加到虚函数表后面。

观察下图中的监视窗口中我们发现看不见func3和func4。

这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数

class Base {

public:

virtual void func1() { std::cout << "Base::func1" << std::endl; }

virtual void func2() { std::cout << "Base::func2" << std::endl; }

private:

int _b;

};

class Derive : public Base {

public:

virtual void func1() { std::cout << "Derive::func1" << std::endl; }

virtual void func3() { std::cout << "Derive::func3" << std::endl; }

virtual void func4() { std::cout << "Derive::func4" << std::endl; }

private:

int _d;

};

typedef void(*VFPTR) ();

void PrintVTable(VFPTR vTable[])

{

// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数

cout << " 虚表地址>" << vTable << endl;

for (int i = 0; vTable[i] != nullptr; ++i)

{

printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);

VFPTR f = vTable[i];

f();

}

cout << endl;

}

int main()

{

Base b;

Derive d;

VFPTR * vTableb = (VFPTR*)(*(int*)&b);

PrintVTable(vTableb);

VFPTR* vTabled = (VFPTR*)(*(int*)&d);

PrintVTable(vTabled);

return 0;

}

（二）多继承中的虚函数表

cpp 复制代码

cpp

class Base1 {

public:

    virtual void func1() {

        std::cout << "Base1::func1" << std::endl;

    }

    virtual void func2() {

        std::cout << "Base1::func2" << std::endl;

    }

private:

    int b1;

};



class Base2 {

public:

    virtual void func1() {

        std::cout << "Base2::func1" << std::endl;

    }

    virtual void func2() {

        std::cout << "Base2::func2" << std::endl;

    }

private:

    int b2;

};



class Derive : public Base1, public Base2 {

public:

    virtual void func1() {

        std::cout << "Derive::func1" << std::endl;

    }

    virtual void func3() {

        std::cout << "Derive::func3" << std::endl;

    }

private:

    int d1;

};

多继承时，派生类会有多个虚函数表（分别对应各个基类），未重写的虚函数放在第一个继承基类部分的虚函数表中，重写的虚函数会更新对应虚函数表中的函数地址。

但是我们观察到

六、C++11 override 和 final

（一）final

final 修饰虚函数，表示该虚函数不能再被重写。例如：

cpp 复制代码

cpp

class Car {

public:

    virtual void Drive() final {}

};



class Benz : public Car {

public:

    // 编译报错，Drive不能被重写

    virtual void Drive() {

        std::cout << "Benz - 舒适" << std::endl;

    }

};

（二）override

override 用于检查派生类虚函数是否重写了基类某个虚函数，如果没有重写则编译报错。例如：

cpp 复制代码

cpp

class Car {

public:

    virtual void Drive() {}

};



class Benz : public Car {

public:

    virtual void Drive() override {

        std::cout << "Benz - 舒适" << std::endl;

    }

};

七、重载、覆盖（重写）、隐藏（重定义）的对比

（一）重载

作用域：两个函数在同一作用域。

条件：函数名相同，参数不同（个数、类型、顺序）。

（二）覆盖（重写）

作用域：两个函数分别在基类和派生类的作用域。

条件：函数名、参数、返回值都必须相同（协变除外），且函数必须是虚函数。

（三）隐藏（重定义）

作用域：两个函数分别在基类和派生类的作用域。

条件：函数名相同，基类和派生类的同名函数不构成重写就是重定义。

八、结语

C++ 多态是一个复杂而精妙的特性，从概念到实现，从原理到应用，都有着丰富的内涵。掌握多态，能让我们编写出更加灵活、可维护和高效的代码。在实际编程中，合理运用多态，结合虚函数、抽象类等知识，可以更好地应对各种复杂的业务需求。希望通过这篇博客，大家能对 C++ 多态有更深入的理解和掌握。