C++ 多态机制详解：概念、实现与原理 | 极客日志

C++算法

C++ 多态机制详解：概念、实现与原理

C++ 多态是面向对象编程的核心特性，允许不同对象对同一消息做出响应。通过虚函数和继承实现运行时绑定，需满足继承关系、虚函数及指针引用调用条件。涉及虚函数表（vtable）原理，单继承与多继承结构不同。抽象类包含纯虚函数不可实例化。C++11 引入 override 和 final 关键字增强安全性。静态成员函数不能为虚函数，构造函数不能为虚函数，析构函数建议设为虚函数。菱形继承存在二义性需虚继承解决。

RefactorPro发布于 2026/3/23更新于 2026/5/36 浏览

C++ 多态机制详解：概念、实现与原理

1. 多态的概念

1.1 概念

通俗来讲，多态就是多种形态。具体一些就是当去完成某个行为的时候，不同的对象去完成时会产生出不同的状态。

2. 多态的定义与实现

2.1 多态的构成条件

多态是在不同继承关系的类对象中，调用同一函数产生不同的行为。例如 Student 继承了 Person，Person 对象买票全价，Student 对象买票半价。在继承中要构成多态还有两个条件：

必须通过基类的指针或者引用调用虚函数。
被调用的函数必须是虚函数，且派生类对基类的虚函数进行重写。

#include <iostream>
using namespace std;

class Adult {
public:
    virtual void BuyTicket() {
        cout << "买票----全价" << endl;
    }
};

class Child : public Adult {
public:
    virtual void BuyTicket() {
        cout << "买票----半价" << endl;
    }
};

void Func(Adult& a) {
    a.BuyTicket();
}

int main() {
    Adult a;
    Child c;
    Func(a);
    Func(c);
    return 0;
}

2.2 虚函数

概念：被 virtual 修饰的类成员函数称为虚函数。

class Person {
public:
       {
        cout <<  << endl;
    }
};

#include <iostream>
using namespace std;

class Person {
public:
    virtual ~Person() {
        cout << "~Person()" << endl;
    }
};

class Student : public Person {
    virtual ~Student() {
        cout << "~Student" << endl;
    }
};

int main() {
    Person* p1 = new Person;
    Person* p2 = new Student;
    delete p1;
    delete p2;
    return 0;
}

#include <iostream>
using namespace std;

class Car {
public:
    virtual void Drive() final { }
};

class Benz : public Car {
    virtual void Drive() { cout << "Benz" << endl; }
};

int main() {
    return 0;
}

#include <iostream>
using namespace std;

class Car final {
public:
    Car() { }
};

class Benz : public Car { }; // 编译报错

int main() {
    return 0;
}

#include <iostream>
using namespace std;

class Car {
public:
    // virtual void drive() { }
};

class Benz : public Car {
public:
    virtual void Drive() override {
        cout << "virtual void Drive()" << endl;
    }
};

int main() {
    return 0;
}

#include <iostream>
using namespace std;

class Car {
public:
    virtual void Drive() = 0;
};

class Benz : public Car {
public:
};

class BMW : public Car {
public:
    virtual void Drive() {
        cout << "BMW()" << endl;
    }
};

int main() {
    Car* pBenz = new Benz;
    pBenz->Drive();
    Car* pBMW = new BMW;
    pBMW->Drive();
    return 0;
}

#include <iostream>
using namespace std;

class Base {
public:
    virtual void Func1() {
        cout << "Func1" << endl;
    }
private:
    int _b = 1;
};

int main() {
    Base b;
    cout << sizeof(b) << endl;
    return 0;
}

#include <iostream>
using namespace std;

class Base {
public:
    virtual void Func1() { cout << "Base::Func1()" << endl; }
    virtual void Func2() { cout << "Base::Func2()" << endl; }
private:
    int _a = 1;
};

class Derive : public Base {
public:
    virtual void Func1() { cout << "Derive::Func1()" << endl; }
    virtual void Func3() { cout << "Derive::Func3()" << endl; }
    virtual void Func4() { cout << "Derive::Func4()" << endl; }
private:
    int _b = 2;
};

// 打印对象虚基表，对象虚基表本质是一个函数指针数组
typedef void(*Vfptr)();
void PrintVfptr(Vfptr* vft) {
    for (size_t i = 0; i < 4; i++) {
        cout << vft[i] << "->";
        vft[i]();
    }
}

int main() {
    Base b;
    Derive d;
    Vfptr* ptr = (Vfptr*)(*(int*)(&d));
    PrintVfptr(ptr);
    return 0;
}

#include <iostream>
using namespace std;

typedef void (*Vfptr)();

class Base1 {
public:
    virtual void func1() { cout << "Base1::func1()" << endl; }
    virtual void func2() { cout << "Base1::func2()" << endl; }
private:
    int _b1;
};

class Base2 {
public:
    virtual void func1() { cout << "Derive:func1()" << endl; }
    virtual void func3() { cout << "Derive:func3()" << endl; }
private:
    int _d1;
};

class Derive : public Base1, public Base2 {
    virtual void func1() { cout << "Derive:func1()" << endl; }
    virtual void func3() { cout << "Derive:func3()" << endl; }
private:
    int _d1;
};

void PrintTable(Vfptr Vtable[]) {
    cout << "虚表地址>" << Vtable << endl;
    for (size_t i = 0; Vtable[i] != nullptr; i++) {
        cout << "第" << i << "个虚函数地址：0X" << Vtable[i] << endl;
        Vtable[i]();
    }
    cout << endl;
}

int main() {
    Derive d;
    /* 取出 d 对象的头 4 个字节，就是虚表的指针 */
    Vfptr* vTableb1 = (Vfptr*)(*(int*)&d);
    PrintTable(vTableb1);
    /* 强转成 char *，char* 类型的指针每次解引用跳过一个字节 */
    Vfptr* vTableb2 = (Vfptr*)(*(int*)((char*)&d + sizeof(Base1)));
    PrintTable(vTableb2);
    return 0;
}

什么是多态？ 通俗来说，就是多种形态，具体一些就是去完成某个行为，当不同的对象去完成的时候会产生出不同的状态。
什么是重载、重写（覆盖）、重定义（隐藏）？
- 重载：两个函数在同一个作用域，函数名相同/参数不同。
- 重写（覆盖）：两个函数分别在基类与派生类的作用域，要满足三同（函数名/参数/返回值都必须相同，协变除外），两个函数都必须是虚函数。
- 重定义（隐藏）：两个函数分别在基类和派生类的作用域，函数名相同，两个基类和派生类的同名函数（不构成重写就是重定义）。
inline（内联函数）可以是虚函数吗？ 可以，不过编译器如果忽略 inline 属性，那么这个函数就不再是 inline 函数，而是会把虚函数表放到虚函数中。
静态成员函数可以是虚函数吗？ 不能，因为静态成员函数没有 this 指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
构造函数可以是虚函数吗？ 不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
析构函数可以是虚函数吗？ 可以，并且最好把基类的析构函数定义成虚函数。
什么场景下析构函数是虚函数？ 如果基类的析构函数为虚函数，此时派生类的析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写。
对象是访问普通函数快还是虚函数快？
1. 首先如果是普通对象，是一样快的。
2. 如果是指针对象或者引用对象，则调用普通函数快一些，因为构成了多态，运行时调用虚函数需要到虚函数表中去查找。
虚函数表是在什么阶段生成的？ 虚函数表是在编译阶段就生成的，一般情况下存在代码段（常量区）的。
C++ 菱形继承的问题，虚继承的原理？ 菱形继承造成了数据冗余和二义性。