前言: 在编程的广阔领域中,多态(Polymorphism) 无疑是一个令人着迷且至关重要的概念。它不仅是面向对象编程(OOP)的三大特性之一(与封装和继承并列),也是实现代码复用、提高软件灵活性和可扩展性的关键所在。当我们谈论C++这门强大的编程语言时,多态更是一个不可或缺的话题
C++作为一种支持多种编程范式的语言,不仅拥有过程式编程的严谨与高效,也具备面向对象编程的丰富与灵活。多态正是这种灵活性的集中体现。它允许我们以统一的方式处理不同类型的对象,无需关心其具体类型,只需知道它们都属于某个共同的基类或接口。这种“以不变应万变”的能力,使得C++程序员在面对复杂多变的业务需求时,能够保持代码的清晰、简洁和可维护性
本文将带领读者一起探索C++多态的奥秘。我们将从多态性的基本概念入手,逐步深入其实现原理,我们将通过丰富的示例代码和详细的解释说明,让我们一起踏上这段探索多态性的旅程吧!
多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为
构成多态的两个条件:
多态代码示例
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student : public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person p;
Student s;
p.BuyTicket();
s.BuyTicket();
return 0;
}
虚函数
概念:被virtual修饰的类成员函数称为虚函数
class Person {
public:
virtual void BuyTicket() // 被virtual修饰
{
cout << "买票-全价" << endl;
}
};
虚函数的重写(覆盖)
概念: 派生类中有一个跟基类完全相同的虚函数(即 派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同),称子类的虚函数重写了基类的虚函数
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student : public Person
{
public:
// 返回值类型、函数名字、参数列表完全相同,构成虚函数的重写
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
注意:
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person
{
public:
// 基类不加virtual也构成虚函数重写,但是不规范
void BuyTicket() { cout << "买票-半价" << endl; }
};
如果基类的析构函数为虚函数,此时派生类析构函数只要定义,无论是否加virtual关键字,都与基类的析构函数构成重写,虽然基类与派生类析构函数名字不同。虽然函数名不相同,看起来违背了重写的规则,其实不然,这里可以理解为编译器对析构函数的名称做了特殊处理,编译后析构函数的名称统一处理成destructor
class Person {
public:
// 析构函数的名称统一处理成destructor
virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
// 无论是否加virtual关键字,都与基类的析构函数构成重写
virtual ~Student() { cout << "~Student()" << endl; }
};
C++对函数重写的要求比较严格,但是有些情况下由于疏忽,可能会导致函数名字母次序写反而无法构成重载,而这种错误在编译期间是不会报出的,只有在程序运行时没有得到预期结果才来debug会得不偿失
因此:C++11提供了override和final两个关键字,可以帮助用户检测是否重写
final:修饰虚函数,表示该虚函数不能再被重写
override:判断一个虚函数是否重写了基类虚函数,如果没有则报错
概念: 在虚函数的后面写上 =0 ,则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。派生类继承后也不能实例化出对象,只有重写纯虚函数,派生类才能实例化出对象
普通函数的继承是一种实现继承,派生类继承了基类函数,可以使用函数,继承的是函数的实现。虚函数的继承是一种接口继承,派生类继承的是基类虚函数的接口,目的是为了重写,达成多态,继承的是接口。所以如果不实现多态,不要把函数定义成虚函数
在开始前先问大家一个 简单的 问题,下面这个类的大小是多少?在类和对象时,我们讲过类的大小判定和结构体差不多,那么在x86中,它的大小到底是不是4bytes?
// 这里常考一道笔试题:sizeof(Pxt)是多少?
class Pxt
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _p = 1;
};
是不是很奇怪为什么它的大小会是8bytes,那么让我们来一探究竟!
通过观察测试我们发现b对象是8bytes,除了_p成员,还多一个_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面,这个跟平台有关),对象中的这个指针我们叫做虚函数表指针(v代表virtual,f代表function)
一个含有虚函数的类中都至少都有一个虚函数表指针,因为虚函数的地址要被放到虚函数表中,虚函数表也简称虚表
基类和派生类不会共用一张虚函数表
同一个自定义类型的对象将会共用一张虚函数表
通过以上测试,我们发现含有虚函数的类中都至少都有一个虚函数表,虚函数的地址要被放到虚函数表中,那么是所有的虚函数的地址都要放进去嘛?我们再来测试以下
虚函数是否都放入虚函数表代码测试
class Base
{
public:
virtual void Func1()
{
cout << "Base::Func1()" << endl;
}
virtual void Func2()
{
cout << "Base::Func2()" << endl;
}
void Func3()
{
cout << "Base::Func3()" << endl;
}
private:
int _b = 1;
};
class Derive : public Base
{
public:
virtual void Func1()
{
cout << "Derive::Func1()" << endl;
}
virtual void Func3()
{
cout << "Base::Func3()" << endl;
}
private:
int _d = 2;
};
int main()
{
Base b;
Derive d;
return 0;
}
结论:
我们用代码来验证一下vs下虚函数表的存放位置
代码示例(验证时使用上面的类(Base)进行验证)
int main()
{
Base b1;
Derive d1;
int a = 99;
Base* b = new Base;
static int c = 99;
const char* p = "const char";
printf("栈区地址:%p\n", &a);
printf("堆区地址:%p\n", b);
printf("静态区地址:%p\n", &c);
printf("代码段地址:%p\n", p);
printf("虚函数表地址:%p\n", *((int*)(&b1))); // 虚表地址比较接近代码段
printf("虚函数地址:%p\n", &Base::Func1);
return 0;
}
多态实则是通过不同的虚表,找到不同的虚函数来调用, 这样就实现出了不同对象去完成同一行为时,展现出不同的形态
看出满足多态以后的函数调用,不是在编译时确定的,是运行起来以后到对象的中取找的。普通的函数调用时编译时确认好的
单继承中的虚函数表
class Base {
public :
virtual void func1() { cout<<"Base::func1" <<endl;}
virtual void func2() {cout<<"Base::func2" <<endl;}
private :
int _a;
};
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;
};
按照上面讲的,我们在d中的虚函数表应该有func3和func4,但是通过监视窗口并没有发现这两个函数,其实编译器的监视窗口故意隐藏了这两个函数,也可以认为是他的一个小bug,那么我们自己将虚表打印出来
打印虚函数表代码示例
// 打印虚表
typedef void (*VFUNC)();
void PrintVFT(VFUNC* a)
{
// 因为虚函数表在vs下最后一个元素是 0,
for (size_t i = 0; a[i] != 0; i++)
{
// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
printf("[%d]: %p -> ", i, a[i]);
VFUNC f = a[i];
f();
}
printf("\n");
}
int main()
{
Base b;
Derive d;
// 类似于打印虚表指针,只不过最后要强制转换成 VFUNC*
PrintVFT((VFUNC*)(*((int*)&b)));
PrintVFT((VFUNC*)(*((int*)&d)));
return 0;
}
注意:有的时候可能会莫名其妙多出很多函数指针,这时我们只需要清理以下解决方案即可
多继承中的虚函数表
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 << "Base2::func1" << endl; }
virtual void func2() { cout << "Base2::func2" << endl; }
private:
int _b2;
};
class Derive : public Base1, public Base2 {
public:
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func3() { cout << "Derive::func3" << endl; }
private:
int _d1;
};
typedef void (*VFUNC)();
void PrintVFT(VFUNC* a)
{
for (size_t i = 0; a[i] != 0; i++)
{
printf("[%d]: %p -> ", i, a[i]);
VFUNC f = a[i];
f();
}
printf("\n");
}
int main()
{
Derive d;
PrintVFT((VFUNC*)(*((int*)&d))); // 打印第一张虚函数表
PrintVFT((VFUNC*)(*((int*)((char*)&d+sizeof(Base1))))); // 打印第二张虚函数表
return 0;
}
我们要想打印第二张虚表就必须跳过第一张,我们来分析一下 ((char*)&d+sizeof(Base1))
我们通过汇编来观察一下虚函数的调用
int main()
{
Derive d;
Base1* p1 = &d;
p1->func1();
Base2* p1 = &d;
p2->func2();
return 0;
}
p1->func1()
p2->func1()
我们发现p2相较于p1调用func1函数进行的步骤多了许多,但是最后发现它们所调用的函数地址相同,所以他们调用的是同一个函数!而进行这么多步骤是为了 修正this指针
注意:
经过对C++多态的深入学习,我们不难发现,多态性是面向对象编程中一个不可或缺的概念,它赋予了代码更高的灵活性和可扩展性。通过虚函数和继承机制,C++实现了运行时多态,让我们能够以统一的方式处理不同类型的对象,这无疑极大地提高了软件开发的效率和质量
在学习的过程中,我们或许会遇到一些挑战和疑惑,但正是这些挑战促使我们不断思考、不断探索。多态性的理解和运用需要我们对C++的类继承、虚函数等核心概念有深入的理解,同时也需要我们在实践中不断积累经验
然而,学习多态性并不仅仅是为了掌握一个编程技巧,更重要的是它培养了我们的编程思维和解决问题的能力。通过多态,我们可以更加灵活地设计软件架构,实现代码复用,提高软件的可维护性和可扩展性。而我们不要满足于对多态性的初步了解,而是要继续深入探索,不断实践。只有在实践中,我们才能真正理解和掌握多态性的精髓,才能将其运用到实际项目中,发挥出其最大的价值
让我们一起在学习的道路上不断前行,探索C++多态的无限可能
最后推荐两篇关于菱形虚拟继承的文章 C++ 虚函数表解析 C++ 对象的内存布局
希望本文能够为你提供有益的参考和启示,让我们一起在编程的道路上不断前行! 谢谢大家支持本篇到这里就结束了,祝大家天天开心!