类的多态（Num020）

#include<iostream>

using namespace std;
//静态联编
void fun() {
	cout << "这是一个函数" << endl;
}

void fun(int x) {
	cout << "这也是一个函数" << endl;
}

int main() {
	fun();
		
	return 0;
}

实现动态联编的条件：

必须把动态联编的行为定义为类的虚函数

必须有类，而且类之间满足父子关系，这个行为通常是重写的父类的虚函数

必须是先使用基类指针或引用指向派生类对象，然后使用基类指针调用虚函数成员其实动态联编就是多态

二、多态：

具有多种形式或者状态

同一个接口，通过不同的对象调用就有不同的效果

多态的实现需要虚函数：

在类中的函数成员前面加一个virtual关键字即可

虚函数的特点：

如果在类中定义的虚函数，那么系统会为这个类维护一个虚函数表

类中会多出4个字节的指针去指向这个虚函数表，在虚函数表中保存了虚函数的首地址，在调用虚函数的时候就会先到表中查找虚函数，然后调用，就比普通函数多了1步操作

虚函数表不会被继承，但是表中的项会被继承（虚函数会被继承）

虚函数的使用：

父类中的虚函数++子类通常都会继承重写为自己的功能++

通过父类指针或引用调用的这个虚函数成员，++父类指针或引用指向哪一个子对象就是调用哪一个子对象的虚函数成员++

如果++子对象是new出来的，那么delete父类指针不会调用子类的析构函数，把父类的析构函数定义为虚析构，那么就会调用子类的析构++

代码示例：

cpp 复制代码

#include<iostream>

using namespace std;

class animal {
public:
	virtual void speak() {
		cout << "这是一个动物会叫" << endl;
	}
	animal() {
		cout << "animal类构造" << endl;
	}
	virtual ~animal() {
		cout << "animal类死亡" << endl;
	}
};

class cat :public animal {
public:
	virtual void speak() {
		cout << "这是一只猫，会喵喵喵" << endl;
	}
};

class dog :public animal {
public:
	virtual void speak() {
		cout << "这是一只狗，会汪汪汪" << endl;
	}
	dog() {
		cout << "dog类构造" << endl;
	}
	~dog() {
		cout << "dog类死亡" << endl;
	}
};

void zoo(animal* a1) {
	a1->speak();
}

int main() {
	//animal a1;
	//cat c1;
	animal* d1=new dog;
	zoo(d1);
	delete d1;
	return 0;
}

三、抽象类：

抽象类++也是一个类，只不过不能拿来定义对象++

抽象类是++用来描述一些公有的属性和行为的++

一个类中++拥有一个纯虚函数，这个类就变为了抽象类++

子类如果++继承了抽象类，那么子类必须重写抽象类中的所有纯虚函数++ （构造析构除外），++否则子类也会变为抽象类++

纯虚函数的定义：++virtual void fun()=0；不需要实现++

代码示例：

头文件：

cpp 复制代码

#pragma once
#include<iostream>

using namespace std;
class CHero
{
public:
	virtual void atk() = 0;
};

class hero1 :public CHero {
public:
	void atk() {
		cout << "发射光线" << endl;
	}
};

class hero2 :public CHero {
public:
	void atk() {
		cout << "飞踢" << endl;
	}
};

class hero3 :public CHero {
public:
	void atk() {
		cout << "肘击" << endl;
	}
};

class bas {
public:
	virtual void atk() = 0;
};

class bas1 :public bas {
public:
	void atk() {
		cout << "怪兽1" << endl;
	}
};

class bas2 :public bas {
public:
	void atk() {
		cout << "怪兽2" << endl;
	}
};

class bas3 :public bas {
public:
	void atk() {
		cout << "怪兽3" << endl;
	}
};

void atk1(CHero& h1, bas& b1) {
	h1.atk();
	b1.atk();
}

同名.cpp文件：

cpp 复制代码

#include "CHero.h"

int main() {
	hero1 h1;
	hero2 h2;
	hero3 h3;

	bas1 b1;
	bas2 b2;
	bas3 b3;

	atk1(h3, b2);
}

四、final：

在虚函数的后面加修饰

在定义类的后面加修饰