C++中的多态与虚函数

        多态是面向对象程序设计的关键技术之一。若程序设计语言不支持多态行，不能称为面向对象的语言。

        多态性是考虑在不同层次类中，以及在同一类中，同名成员函数之间的问题。

        函数重载，运算符重载，属于编译时的多态性。

        以类的虚成员函数为基础的运行时的多态性，是面向对象设计的标志性特征，体现了类推和比喻的思想方法。

 编译时多态，早期绑定。

int MAX(int a,int b)
{
    return a>b?a:b;
}
char MAX(char A,char b)
{
    return a>b?a:b;
}
double MAX(char A,char b)
{
    return a>b?a:b;
}
int main ()
{
    int x=MAX(12,23);
    char ch=MAX('c','b');
    double dx=MAX(12.23,23.45);
    return 0;
}

运行时多态

运行时多态的设计思想：

        对于相关的类型，确定它们之间的一些共同特征，（属性和方法），将共同特征被转移到基类中，然后在基类中，把这些共同的函数或者或方法声明为公有的虚函数接口，然后使用派生类继承基类，并且在派生类中重写这些虚函数，以完成具体的功能，这种设计使得共性很清楚，避免了代码重复，将来容易增强功能，并易于长期维护。

        客户端代码（操作函数）通过基类的引用或指针来指向这些派生类的对象，对虚函数的调用会自动绑定到派生类对象上的重写的虚函数。

        虚函数是一个类的成员函数，定义格式如下：

扫描二维码关注公众号，回复： 14783529 查看本文章

        virtual 返回类型 函数名 （参数表）；

        关键字virtual指明该成员函数为虚函数，只能将类的成员函数定义为虚函数，当某一个类的成员函数定义为虚函数，则由该类派生出来的所有派生类中，该函数始终保持着虚函数的特性。

运行时的多态性，晚绑定

class Animal
{
public:
	Animal(const char* na)
	{
		strcpy(name, na);
	}
	~Animal(){}
	virtual void eat()
	{
		cout << "eat" << endl;
	}
	virtual void walk()
	{
		cout << "walk" << endl;
	}
	virtual void talk()
	{
		cout << "talk" << endl;
	}
	virtual void printInfo()
	{
	}
	const char* GetName()const { return name; }
private:
	char name[20];
};
class Dog :public Animal
{
public:
	Dog(const char* own, const char* na):Animal(na)
	{
		strcpy(owner, own);
	}
	~Dog(){}
	virtual void eat()
	{
		cout << "Dog Eat:bone" << endl;
	}
	virtual void walk()
	{
		cout << "Dog Talk:wangwang" << endl;
	}
	virtual void printInfo()
	{
		cout << "Dog Owner:" << owner << endl;
		cout << "Dog Name:" << GetName() << endl;
	}
private:
	char owner[20];
};
class Cat :public Animal
{
public:
	Cat(const char* own, const char* na) :Animal(na)
	{
		strcpy(owner, own);
	}
	~Cat(){}
	virtual void eat()
	{
		cout << "Cat Eat:fish" << endl;
	}
	virtual void walk()
	{
		cout << "Cat walk:silent" << endl;
	}
	virtual void talk()
	{
		cout << "Cat Talk:Miao Miao" << endl;
	}
	virtual void printInfo()
	{
		cout << "Cat Owner:" << owner << endl;
		cout << "Cat Name" << GetName() << endl;
	}
	private:char owner[20];
};
void funa(Animal animal)
{
	animal.eat();
	animal.walk();
	animal.talk();
	animal.printInfo();
}
void funb(Animal* animal)
{
	animal->eat();
	animal->walk();
	animal->talk();
	animal->printInfo();
}
void func(Animal& animal)
{
	animal.eat();
	animal.walk();
	animal.talk();
	animal.printInfo();
}
int main()
{
	Dog dog("yhping", "hashiqi");
	Cat cat("tulun", "persian");
	func(dog);
	func(cat);
	return 0;
}

总结：运行时的多态性：公有继承+虚函数+（指针或者引用调用虚函数）

定义虚函数的规则

类的成员函数定义为虚函数，但必须注意一下几条

1.派生类中定义虚函数必须与基类中的虚函数同名外，还必须同参数表，同返回类型。否则被认为是隐藏，不具有多态性。如基类中返回基类指针，派生类中返回派生类指针是允许的，这是一个例外。

2.只有类的成员函数才能说明为虚函数。这是因为虚函数仅适用于有继承关系的类对象。友元函数和全局函数也不能作为虚函数。

3.静态成员函数，是所有同一类对象共有，不受限于某个对象，不能作为虚函数。

4.内联函数每个对象一个拷贝，无映射关系，不能作为虚函数。

5.构造函数和拷贝构造函数不能作为虚函数。构造函数和拷贝构造函数是设置虚表指针。

6.析构函数可定义为虚函数，构造函数不能定义为虚函数，因为在调用构造函数时对象还没有完成实例化（虚表指针没有设置）。在基类中及其派生类中都动态分配的内存空间时，必须析构函数定义为虚函数，实现撤销对象时的多态性

7.实现运行时的多态，必须使用基类类型的指针变量或引用，使该指针指向该基类的不同派生类的对象，并通过该指针指向虚函数，才能实现运行时的多态。

8.在运行时的多态，函数执行的速度要稍微慢一点：为了实现多态性，每一个派生类中均要保存响应虚函数的入口地址表，函数的调用机制也是间接实现。所以多态性总要付出一定代价，但通用性是一个更高的目标。

9.如果定义在类外，virtual只能加在函数声明前面，不能加在函数定义前面·。正确的定义必须不包括virtual。

虚函数表的示例：运行时的多态的原理

虚函数指针表简称虚表，虚表就是虚函数指针的集合，虚函数指针表本质是一个存储虚函数指针的指针数组，这个数组首元素之上存储着RTTI（运行时类型识别信息的指针），从数组下标0开始依次存储虚指针地址，最后面放了一个nullptr。