第十一站:C++面向对象-多态
为什么要使用多态
当定义的子类继承父类并重写父类的方法后,
父类使用指针调用子类的同名方法,得到的却是父类同名方法的结果
#include
using namespace std;
class Father
{
public:
void play() {
cout << "一起去KTV唱歌吧" << endl;
};
};
class Son :public Father {
public:
void play() {
cout << "一起去打游戏吧!" << endl;
};
};
void testPlay(Father** man, int n) {
for (int i = 0; i < n; i++) {
man[i]->play();//man[i] = *man;
}
}
int main(void) {
Father father;
Son son1, son2;
Father* p[3] = { &father,&son1,&son2 };
int len = sizeof(p) / sizeof(p[0]);
testPlay(p, len);
} 使用多态后(父类方法声明时关键字virtual :虚函数):
是在父类方法声明的时候添加virtual关键字,实现的时候不需要添加
子类重写该方法的时候也可以添加,
父类
virtual void play() {
cout << "一起去KTV唱歌吧" << endl;
};子类
virtual void play() {
cout << "一起打游戏吧!" << endl;
};
多态的本质
形式上，使用 统一的父类指针做一般性处理，
但是实际执行时，这个 指针可以指向子类对象，
形式上，原本调用父类的方法，但是 实际上会调用子类的同名方法。
注意:程序执行时，父类指针指向父类对象，或子类对象时，在形式上是无法分辨的！只有通过多态机制，才能执行真正对应的方法。
虚函数表(32位下调试)
这里一个对象理应内存分布:一个虚函数指针+两个int成员数据(12个字节)
//虚函数是存放在虚函数表里的
//虚函数表没有占用对象的内存空间,对象内存空间中只有一个虚函数指针
virtual void fun1() {cout << "virtual:fun1()" << endl;}
virtual void fun2() { cout << "virtual:fun2()" << endl; }
virtual void fun3() { cout << "virtual:fun3()" << endl; }//普通成员函数在代码区
void fun4() { cout << "非虚函数:fun1()" << endl; }public:
int x = 200;
int y = 300;static int z;//静态成员数据在内存的全局数据区
测试
#include
using namespace std;
class Father{
public:
//虚函数是存放在虚函数表里的
//虚函数表没有占用对象的内存空间,对象内存空间中只有一个虚函数指针
virtual void fun1() {cout << "Father:fun1()" << endl; }
virtual void fun2() { cout << "Father:fun2()" << endl; }
virtual void fun3() { cout << "Father:fun3()" << endl; }
//普通成员在代码区
void fun4() { cout << "非虚函数:Father::fun4()" << endl; }
int x = 200;
int y = 300;
static int z;//静态成员数据在内存的全局数据区
};
int Father::z = 0;
//定义一个void型函数指针
//virtual void fun1() {cout << "Father:fun1()" << endl;}
typedef void (*fun_t)(void);
int main(void) {
Father father;
cout << father.x << endl;
//一个虚函数大小
//虚函数表没有占用对象的内存空间,对象内存空间中只有一个虚函数指针,指向虚函数表
//理应,这里只占12个字节
cout << "sizeof(father)的大小:" << sizeof(father) << endl;
cout << "对象的地址" << (int*)&father << endl;
//先将father的值16进制的地址转换成int*的指针,在取值,然后再转换成int*的指针进行赋值
int* vptr = (int*)(*(int*)&father);
cout << "虚函数指针vptr的地址值" << vptr << endl;
cout << "调用第一个虚函数:";
((fun_t) * (vptr + 0))();//等同于调用void father::fun1(void);
cout << "调用第二个虚函数:";
((fun_t) * (vptr + 1))();//等同于调用void father::fun2(void);
cout << "调用第三个虚函数:";
((fun_t) * (vptr + 2))();//等同于调用void father::fun3(void);
cout << "第一个数据成员的地址:" << endl;
cout << &father.x << endl;
cout << std::hex << (int) & father + 4 << endl;
cout << "第一个数据成员的值:" << endl;
cout < 子类继承父类虚函数
子类虚函数的三种状态
完全继承父类
直接复制父类的虚函数表
子类重写父类的
在父类虚函数的对应位置进行替换
当父类再次指向子类的时候,子类中的虚函数表已经发生改变,父类这时候调用虚函数得到的就是子类的虚函数表中对应的东西
子类自己的虚函数
将新增的虚函数添加到已有虚函数表尾部
#include
using namespace std;
class Father{
public:
//虚函数是存放在虚函数表里的
//虚函数表没有占用对象的内存空间,对象内存空间中只有一个虚函数指针
virtual void fun1() {cout << "Father:fun1()" << endl; }
virtual void fun2() { cout << "Father:fun2()" << endl; }
virtual void fun3() { cout << "Father:fun3()" << endl; }
//普通成员在代码区
void fun4() { cout << "非虚函数:Father::fun4()" << endl; }
int x = 200;
int y = 300;
static int z;//静态成员数据在内存的全局数据区
};
int Father::z = 0;
class Son :public Father {
public:
//继承父类的虚函数
virtual void fun1() { cout << "Son:fun1()" << endl; }
//自己的虚函数
virtual void fun4() { cout << "Son:fun4()" << endl; }
};
//定义一个void型函数指针
//virtual void fun1() {cout << "Father:fun1()" << endl;}
typedef void (*fun_t)(void);
int main(){
Son son;
int* vptr1 = (int*)*(int*)&son;
cout << "son的地址:" << (int*) & son << endl;
cout << "sizeof(son)的值:" << sizeof(son) << endl;
for (int i = 0; i < 4; i++){
cout << "调用第" << i + 1 << "个虚函数:";
((fun_t) * (vptr1 + i))();
}
for (int i = 1; i <= 2; i++){
cout << "第" << i << "个成员的值"< 使用多重继承的虚函数表
#include
using namespace std;
class Father{
public:
//虚函数是存放在虚函数表里的
//虚函数表没有占用对象的内存空间,对象内存空间中只有一个虚函数指针
virtual void fun1() {cout << "Father:fun1()" << endl; }
virtual void fun2() { cout << "Father:fun2()" << endl; }
virtual void fun3() { cout << "Father:fun3()" << endl; }
//普通成员在代码区
void fun4() { cout << "非虚函数:Father::fun4()" << endl; }
int x = 200;
int y = 300;
static int z;//静态成员数据在内存的全局数据区
};
int Father::z = 0;
//另外一个基类
class Monther {
public:
//虚函数是存放在虚函数表里的
//虚函数表没有占用对象的内存空间,对象内存空间中只有一个虚函数指针
virtual void handel() { cout << "Monther:handl()" << endl; }
virtual void hande2() { cout << "Monther:handl2()" << endl; }
//普通成员在代码区
void fun() { cout << "非虚函数:Father::fun4()" << endl; }
int m = 400;
int n = 600;
static int z;//静态成员数据在内存的全局数据区
};
class Son :public Father ,public Monther{
public:
//继承父类的虚函数
virtual void fun1() { cout << "Son:fun1()" << endl; }
//自己的虚函数
virtual void fun4() { cout << "Son:fun4()" << endl; }
//继承另外一个基类的虚函数
virtual void hande2() { cout << "Son:handl2()" << endl; }
};
//定义一个void型函数指针
//virtual void fun1() {cout << "Father:fun1()" << endl;}
typedef void (*fun_t)(void);
int main(){
Son son;
int* vptr1 = (int*)*(int*)&son;
cout << "第一个虚函数表的指针" << vptr1 << endl;
//第二个虚函数表
// 一个虚函数指针,两个成员数据
int* vptr2 = (int*)*((int*)&son+3);
cout << "第二个虚函数表的指针" << vptr2 << endl;
cout << "son的地址:" << (int*) & son << endl;
cout << "sizeof(son)的值:" << sizeof(son) << endl;
for (int i = 0; i < 4; i++){
cout << "调用第" << i + 1 << "个虚函数:";
((fun_t) * (vptr1 + i))();
}
for (int i = 1; i <= 2; i++){
cout << "第" << i << "个成员的值"< final关键字
设置该类不能被继承
class i1 {
};
class i2 final :public i1{};
class i3 :public i2{};
设置该成员函数不能被重写(final只能用于虚函数中)
class i1 {
virtual void chat()final {
cout << "聊天一代" << endl;
};
};
class i2 :public i1 {
virtual void chat();
};
override仅能虚函数(仅限函数声明时可以写)
作用：1. 提示程序的阅读者，这个函数是重写父类的功能。2. 防止程序员在重写父类的函数时，把函数名写错。
class i1 {
public:
virtual void chat() {
cout << "聊天一代" << endl;
};
};
class i2 :public i1 {
public:
virtual void chat()override;
};
消失的析构函(析构函数最好加上virtual)
#include
#include
using namespace std;
class Father {
public:
Father(const char* addr = "中国") {
cout << __FUNCTION__ << endl;
int len = strlen(addr) + 1;
this->addr = new char[len];
strcpy_s(this->addr,len, addr);
};
~Father() {
cout << __FUNCTION__ << endl;
if (addr) {
delete[] addr;
addr = NULL;
}
};
private:
char* addr;
};
class Son:public Father {
public:
Son(const char* addr = "中国",const char *game = "推箱子"):Father(addr) {
cout << __FUNCTION__ << endl;
int len = strlen(game) + 1;
this->game = new char[len];
strcpy_s(this->game, len, game);
};
~Son() {
cout << __FUNCTION__ << endl;
if (game) {
delete[] game;
game = NULL;
}
};
private:
char* game;
};
int main(void) {
string line(50, '-');
Father* father = new Father();
delete father;
cout << line << endl;
Son* son = new Son();
delete son;
cout << line << endl;
Father* father1 = new Son();
delete father1;
cout << line << endl;
} 上述可以看出
父类的通过子类定义的对象,释放之后,只释放了父类的空间,子类并没有释放;
解决:将父类的析构函数定义为虚函数
作用:当对父类的指针进行delete的时候,就会对该指针使用"动态析构"[如果这个指针是指向子类对象,那么就会先调用该子类的析构函数,然后再调用父类的]
virtual ~Father() {
纯虚函数和抽象函数
纯虚数(仅提供接口,实际方法由子类实现)
抽象类(拥有纯虚数的的类就是抽象类),抽象类无法创建对象
//把eat方法定义为纯虚数
virtual void eat() = 0;
1:纯虚函数一定要被实现才会结束抽象这个类 ,
2:要么不对这个纯虚函数做任何处理，等效于下一种情况（该方式不推荐）
3:要么继续把这个纯虚函数声明为纯虚函数，这个子类也成为抽象类virtual void eat() = 0;
#include
#include
using namespace std;
class Shape {
public:
Shape(const string& color = "白色") { this->color = color; }
string getColor()const {
return color;
}
//定义一个纯虚数
virtual float area() = 0;
private:
string color;
};
class Circle :public Shape {
public:
Circle(float radios, const string& color) :Shape(color),r(radios){};
//实现父类的纯虚数
float area() { return 3.14 * r * r; }
private:
float r;
};
int main(void) {
//Shape shape;
Circle cir(2,"白色");
cout<