【C++】多态
目录
1. 什么是多态
2. 多态的定义
2.1. 多态构成条件
2.2. 虚函数
2.3. 虚函数的重写
2.4. 多态的使用
2.5. 虚函数重写的两个例外
2.5.1 协变(基类与派生类虚函数返回值类型不同) (了解)
2.5.2 析构函数的重写(基类与派生类析构函数的名字不同)
2.6. 子类继承父类虚函数会继承虚函数的属性
2.7. final 和 override(C++11)
2.7.1 final
2.7.2 override
2.8. 重载、重定义(隐藏)、重写(重定义)对比
3.抽象类
3.1. 什么是抽象类
3.2. 接口继承和实现继承
4. 多态原理(★)
4.1虚函数表
4.2. 多态的实现原理
4.3. 多态的静态与动态
5. 单继承和多继承的虚函数表
5.1. 单继承的虚函数表
5.2. 多继承的虚函数表(了解)
1. 什么是多态
我的理解是：不同的对象完成某个相同的行为，会产生不同的状态。
多态分为编译时多态和运行时多态。
编译时多态(静态)：例如函数重载，看起来是调用同一个函数，却有不同的行为
运行时多态(动态)：父类的指针或引用去调用函数，传递不同的对象，会调用不同的函数
例如：
去商场购物，有些商场根据以往消费情况将会员分为普通会员、黄金会员、钻石会员...不同的会员在消费时可以使用不同的折扣对商品打折。
2. 多态的定义
2.1. 多态构成条件
在继承中要构成多态的两个条件：
必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
2.2. 虚函数
虚函数：即被virtual修饰的类成员函数称为虚函数(只能是类的非静态成员函数) 。
class ordinary_member
{
public:
virtual void discount() // 虚函数
{
cout << "不打折" << endl;
}
};2.3. 虚函数的重写
虚函数的重写(覆盖)： 派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的 返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
例如：
class ordinary_member
{
public:
virtual void discount()
{
cout << "不打折" << endl;
}
};
class gold_member:public ordinary_member
{
public:
virtual void discount() // 虚函数重写：函数名、返回值、参数列表完全相同(三同)
{
cout << "打八折" << endl;
}
};注意：这里子类中的discount函数不是重定义(隐藏)，而是重写。
2.4. 多态的使用
class ordinary_member
{
public:
virtual void discount()
{
cout << "不打折" << endl;
}
};
class gold_member:public ordinary_member
{
public:
virtual void discount()
{
cout << "打八折" << endl;
}
};
//构成多态，传的哪个类型的对象，就调用这个对象的虚函数(跟对象有关)
void test(ordinary_member& member)
{
member.discount(); // 多态
}
// 不构成多态，只会调用member类型的函数(跟类型有关)
//void test(ordinary_member member) // 如果用父类的对象接受，不构成多态
//{ // 换言之，在这个函数中，只要不构成多态，discount函数只会调用父类的
// member.discount();
//}
int main()
{
ordinary_member o;
gold_member g;
test(o);f
test(g); // test函数用父类对象的引用或指针接收，传子类对象会切片
return 0;
}
2.5. 虚函数重写的两个例外
2.5.1 协变(基类与派生类虚函数返回值类型不同) (了解)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变 。
class A
{
public:
virtual A* fun()
{
return new A;
}
};
class B:public A
{
public:
virtual B* fun()
{
return new B;
}
};2.5.2 析构函数的重写(基类与派生类析构函数的名字不同)
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。
虽然函数名不相同，看起来违背了重写的规则，其实不是，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
比如：vector的析构函数
思考：为什么析构函数需要多态？
如果用将一个动态申请子类对象赋值给一个父类指针，那么调用析构函数时，应该调用谁的析构函数？
如果调用父类的析构函数，那么子类的成员不能被析构，所以这里析构函数应该存在多态，去调用子类的析构。
(普通对象会正确调用)
若析构函数不构成多态：
class ordinary_member
{
public:
virtual void discount()
{
cout << "不打折" << endl;
}
~ordinary_member()
{
cout << "~ordinary_member" << endl;
}
};
class gold_member :public ordinary_member
{
public:
virtual void discount()
{
cout << "打八折" << endl;
}
~gold_member()
{
cout << "~gold_member" << endl;
}
};
int main()
{
ordinary_member* o1 = new ordinary_member;
ordinary_member* o2 = new gold_member;
delete o1;
delete o2; // 调用父类析构函数
return 0;
}那么这里都会调用父类的析构函数，子类自己成员不会被析构！
如析构函数构成多态：
class ordinary_member
{
public:
virtual ~ordinary_member()
{
cout << "~ordinary_member" << endl;
}
};
class gold_member:public ordinary_member
{
public:
virtual ~gold_member()
{
cout << "~gold_member" << endl;
}
};
int main()
{
ordinary_member* o1 = new ordinary_member;
ordinary_member* o2 = new gold_member;
// 析构 + operator delete()
delete o1; // o1->destructor()
delete o2; // o2->destructor() 析构时会调用子类的析构函数
return 0;
}o1指针指向父类，调用父类的析构函数；o2指针指向子类，调用子类的析构函数！
所以动态申请的子类对象赋值父类指针管理，需要析构函数是虚函数。
2.6. 子类继承父类虚函数会继承虚函数的属性
虚函数的重写允许父子类两个都是虚函数，或者父类是虚函数，满足重写就构成多态(建议都写)
也就是说子类在继承父类虚函数时会将虚函数的属性也继承下来，包括virtual、访问限定符
(子类重写的虚函数可以不加virtual本质是因为析构函数，防止项目中忘记加virtual导致内存泄漏；而因为析构函数本身特性，只要父类析构函数前加了virtual，就和子类析构函数构成重写)
class ordinary_member
{
public:
virtual void discount()
{
cout << "不打折" << endl;
}
};
class gold_member :public ordinary_member
{
private：// 子类访问限定符为私有，但这个虚函数构成多态，也能被外界访问(这里的private不能限制这个虚函数)
void discount() // 不写virtual 也构成多态
{
cout << "打八折" << endl;
}
};
void test(ordinary_member& member)
{
member.discount(); // 子类私有成员构成多态时，可以在外面用多态调用该函数
}
int main()
{
ordinary_member o;
gold_member g;
test(o);
test(g);
return 0;
}
2.7. final 和 override(C++11)
2.7.1 final
- 被final修饰的类，不能被继承
class A
{
private:
A() // 将父类的构造函数设为私有，子类无法调用父类的构造函数，就可以使父类不能被继承(间接限制)
:_a(0)
{}
protected:
int _a;
};
class B :public A{};
class C final {}; // 类后面加了final，表示这个类不能被继承(直接限制)
class D:public C {};
int main()
{
B b; // 编译报错
return 0;
}-
被final修饰的虚函数，不能被重写
class A
{
public:
virtual void Print() final // final修饰虚函数，该虚函数不能被重写
{
cout << "A::Print()" << endl;
}
};
class B:public A
{
public:
virtual void Print()
{
cout << "B::Print()" << endl;
}
};
2.7.2 override
检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错 。（放在子类重写虚函数的后面）
class A
{
public:
void Print()
{
cout << "A::Print()" << endl;
}
};
class B:public A
{
public:
virtual void Print() override // 虚函数没有完成重写，会编译报错
{
cout << "B::Print()" << endl;
}
};
2.8. 重载、重定义(隐藏)、重写(重定义)对比
3.抽象类
3.1. 什么是抽象类
在虚函数的后面写上 =0 ，则这个函数为纯虚函数。
包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。
派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。
纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承 。
例如：
class member // 抽象类,不能用这个类实例化出对象
{
public:
virtual void discount() = 0; // 纯虚函数，只声明，不用实现因为实现了没用，不会调用父类的纯虚函数
};
class ordinary_member :public member
{
public:
virtual void discount()
{
cout << "不打折" << endl;
}
};
class gold_member :public member
{
public:
virtual void discount()
{
cout << "打八折" << endl;
}
};
class diamond_member :public member
{
virtual void discount()
{
cout << "打六折" << endl;
}
};
int main()
{
member* gm = new gold_member;
member* dm = new diamond_member;
gm->discount();
dm->discount();
delete om;
delete gm;
delete dm;
return 0;
}3.2. 接口继承和实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
虚函数的 继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。
所 以如果不实现多态，不要把函数定义成虚函数。
例如上面的会员类，一个单纯的会员类是抽象的东西(必要区分会员类型)，因为不知道到底是普通会员还是黄金会员或者钻石会员，而每个会员所独有的折扣(特性)是必须要存在的，为了不让子类缺少这部分，子类就必须重写纯虚函数才能实例化出对象。
4. 多态原理(★)
4.1虚函数表
下面这个类的对象大小是多少？
class A
{
public:
virtual void fun()
{
cout << "A::fun()" << endl;
}
private:
int _a;
};
int main()
{
A aa;
cout << sizeof(aa) << endl;
return 0;
}
在监视窗口中可以看到，aa对象中多了一个__vfptr成员，这其实是一个指向虚函数表的指针，而虚函数表是一个函数指针数组，里面放的是虚函数的地址。
再往下看：
class ordinary_member
{
public:
virtual void discount()
{
cout << "不打折" << endl;
}
protected:
int _a;
};
class gold_member :public ordinary_member
{
public:
virtual void discount()
{
cout << "打八折" << endl;
}
protected:
int _b;
};
void consumption(ordinary_member* member)
{
member->discount();
}
int main()
{
ordinary_member om;
gold_member gm;
consumption(&om);
consumption(&gm);
return 0;
}根据上面的代码，调用监视窗口查看，对象中的内容：
虚函数的地址都会被放进虚函数表中，不管有没有被重写！但编译器进行了处理，导致看不见。
同类型的虚表指针是一样的！(虚表在内存中只会被存一份)
ordinary_member om1;
ordinary_member om2;
ordinary_member om3;
ps：在vs下一般认为虚函数表放在常量区。
4.2. 多态的实现原理
为什么需要使用父类的指针或引用才能调用多态？
例如上面这段代码，我们将consumption函数的参数改为父类的对象：
void consumption(ordinary_member member)
{
member.discount();
}
int main()
{
ordinary_member om;
gold_member gm;
consumption(om);
consumption(gm);
return 0;
}我们会发现，无论是传父类对象还是子类对象，都会调用父类中的discount函数。
这是因为传子类对象过去后，父类对象member会对子类进行切片，而站在父类的角度它只会调用父类中的成员函数，不会调用子类。
也就是说子类传过去后，member对象会将子类中的父类成员进行拷贝，而__vfptr(虚表指针)不会被拷贝，还是会使用父类的虚表指针。因为父类中的虚表是不能被改变的，所以__vfptr也不能改变。(如果改变了，使用父类实例化对象时就会使用子类的虚表)
所以父类的对象调用重写函数不会形成多态！
再来看看传指针和引用的情况：
父类对象：
子类对象：
传指针或引用就可以构成多态，是因
-
静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数 重载
-
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用 具体的函数，也称为动态多态
为使用父类对象的指针或引用接收后，不会改变对象本身的性质，传父类就会使用父类的原地址或原空间，传子类就使用子类中继承父类的那部分成员(相当于这里的父类对象是子类中父类那一部分的别名)。(也就是说这里不会存在拷贝行为，还是在原对象的空间中操作)
多态的原理：基类的指针或引用，只指向谁就去谁的虚函数表中找对应位置的虚函数调用
4.3. 多态的静态与动态
静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数 重载
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用 具体的函数，也称为动态多态
class ordinary_member
{
public:
virtual void discount()
{
cout << "不打折" << endl;
}
protected:
int _a;
};
class gold_member :public ordinary_member
{
public:
virtual void discount()
{
cout << "打八折" << endl;
}
void fun()
{
cout << "gold_member::fun()" << endl;
}
protected:
int _b;
};
int main()
{
gold_member *gm = new gold_member;
gm->discount();
gm->fun();
return 0;
}
5. 单继承和多继承的虚函数表
5.1. 单继承的虚函数表
class A
{
public:
virtual void fun1()
{
cout << "A::fun1()" << endl;
}
virtual void fun2()
{
cout << "A::fun2()" << endl;
}
};
class B :public A
{
public:
virtual void fun3()
{
cout << "B::fun3()" << endl;
}
virtual void fun4()
{
cout << "B::fun5()" << endl;
}
};
int main()
{
A a;
B b;
return 0;
}观察下图中的监视窗口中发现看不见fun3和fun4。这里是前面说的，编译器的监视窗口故意隐藏了这两个函数。
通过查看内存，是可以知道他们的存在于虚函数表的：
5.2. 多继承的虚函数表(了解)
class A
{
public:
virtual void fun1()
{
cout << "A::fun1()" << endl;
}
virtual void fun2()
{
cout << "A::fun2()" << endl;
}
};
class B
{
public:
virtual void fun3()
{
cout << "B::fun3()" << endl;
}
virtual void fun4()
{
cout << "b::fun4()" << endl;
}
};
class C :public A, public B
{
virtual void fun1()
{
cout << "C::fun1()" << endl;
}
virtual void fun5()
{
cout << "C::fun5()" << endl;
}
};
int main()
{
C c;
return 0;
}多继承的子类中存在两张虚表，且子类中未重写的虚函数放在第一张虚表中。
6. 总结
1.什么是多态
不同类型的对象完成某个相同的行为，会产生不同的结果。
2.inline函数可以是虚函数吗？
可以
调用时，如果不构成多态，这个函数保持inline属性；如果构成多态，这个函数就没有inline属性，因为调用是到对象的虚函数表中找到虚函数地址，实现调用，无法使用inline属性
3.静态成员函数可以是虚函数吗？
不能
静态成员函数没有this指针，不能访问到虚函数表指针，而且可以通过 类型::静态成员函数 的方式调用，无法访问虚表
4.构造函数可以是虚函数吗？
不能
虚函数表指针是在初始化列表阶段初始化的，如果构造函数是虚函数，这时还没有虚函数表指针，访问不到虚函数表
5.析构函数可以是虚函数吗？
可以
出现这种情况时需要使析构函数是虚函数
Parent* ptr = new child;(动态申请的子类对象，用父类指针接收时)
6.对象访问普通函数快还是虚函数更快？
如果不构成多态，都是编译器确定调用函数的地址，一样快。
如果构成多态，虚函数调用实在运行时，去虚表中确定函数地址，普通函数编译时直接确定地址，普通函数更快。
7.以下程序输出结果是什么（）
class A
{
public:
virtual void func(int val = 1)
{ std::cout<<"A->"<< val <"<< val <test();
return 0;
} 