C++学习笔记之多态（虚函数）

第一、

多态可以分为静态的多态和动态多态，静态多态即所谓的函数重载，在编译阶段即可确定是使用哪个函数。动态多态是通过虚函数来实现的，并基于类的继承来表现。

在使用过程中应注意以下几点：

1、虚函数使用过程中，需要用父类指针指向子类，如下例子中Animal *Ani = new Dog;

2、在子类中的同名虚函数是可加关键字virtual也可不加，但是为方便代码阅读，建议是进行添加

3、当子类中的构造函数中存在new对象或者空间时，为避免内存的泄露，需要将父类中的析构函数定义为虚函数。这是因为析构函数定义为虚函数后，在main函数中调用delete Ani进行析构的时候，会自动调用子类的析构函数，由于调用子类的析构函数会自动析构父类；而析构父类是无法自动析构子类的。

4、普通的全局函数、静态成员函数和构造函数都是不能够指定为虚函数的。对于inline修饰的内联函数，当用virtual对其进行修饰时，inline是失效的。

5、父类即使不做任何的定义，单纯是一个空的构造函数和空的析构函数，在对父类进行实例化为对象的时候也是占用1个内存空间的，即对该父类对象进行sizeof衡量时，输出结果为1,。该1个单元的内存空间是用以标定该对象的存在的，当该父类中有其他如int成员时，就不需要该标定空间的。同时，当父类中定义了虚函数时，则实例化后会由于存在一个虚函数表指针，使得该父类的对象的内存空间为4（指针嘛，空间占用是4个单元）。而从该父类继承的所有子类都是会存在一个虚函数表指针的。

定义一个动物（animal）类，要求含有虚函数eat和move，并定义构造函数和虚析构函数
定义一个狗（Dog）类，要求共有继承动物类，定义构造函数和虚析构函数，并实现自己的eat和move函数
使用父类对象实例化子类，调用子类成员函数。

代码：

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 *  定义动物类：Animal
 *  成员函数：eat()、move()
 */
class Animal
{
public:
    // 构造函数
    Animal(){cout << "Animal" << endl;}
    // 析构函数
	virtual ~Animal(){cout << "~Animal" << endl;}
    // 成员函数eat()
	virtual void eat(){cout << "Animal -- eat" << endl;}
    // 成员函数move()
    virtual void move(){cout << "Animal -- move" << endl;}
};

/**
 * 定义狗类：Dog
 * 此类公有继承动物类
 * 成员函数：父类中的成员函数
 */
class Dog : public Animal
{
public:
    // 构造函数
	Dog(){cout << "Dog" << endl;}
    // 析构函数
	virtual ~Dog(){cout << "~Dog" << endl;}
    // 成员函数eat()
	virtual void eat(){cout << "Dog -- eat" << endl;}
    // 成员函数move()
	virtual void move(){cout << "Dog -- move" << endl;}
};

int main(void)
{
    // 通过父类对象实例化狗类
	Animal *Ani = new Dog;
    // 调用成员函数
	Ani->eat();
    Ani->move();
    // 释放内存
    delete Ani;
    
    
	return 0;
}

第二、

纯虚函数：

当虚函数并没有做任何定义时，该虚函数称为纯虚函数，含有纯虚函数的类，称为抽象类。所以，子类也可能是抽象类。注意一点是，抽象类是无法进行实例化对象的！

代码如下：

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 * 定义动物类：Animal
 * 虚函数：eat()
 * 纯虚函数：move()
 * 数据成员：m_strName
 */
class Animal
{
public:
    // 默认构造函数
    Animal(){};
    // 含参构造函数
	Animal(string name){m_strName = name; cout << "Animal" << endl;}
    // 虚析构函数
	virtual ~Animal(){cout << "~Animal" << endl;}
    // 虚成员函数
	virtual void eat(){cout << "Animal--" << m_strName << "-- eat" << endl;}
    // 纯虚函数
	virtual void move()=0;
public:
    // 数据成员
	string m_strName;
};

/**
 * 定义狗类：Dog
 * 公有继承动物类
 * 虚成员函数：eat()、move()
 */
class Dog : public Animal
{
public:
    // 默认构造函数
    Dog(){};
    // 含参构造函数
	Dog(string name){m_strName = name; cout << "Dog" << endl;}
    // 虚析构函数
	 virtual ~Dog(){cout << "~Dog" << endl;}
    // 虚成员函数eat()
	virtual void eat(){cout << "Dog--" << m_strName << " -- eat" << endl;}
    // 虚成员函数move()
	virtual void move(){cout << "Dog--" << m_strName << " -- move" << endl;}
public:
    // 数据成员
	string m_strName;
};

int main(void)
{
    // 通过动物类实例化狗类
    Animal *Ani=new Dog("dog007");
    // 调用成员函数
	Ani->eat();
    Ani->move();
    // 释放内存
	delete Ani;
	Ani=NULL;
    
	return 0;
}

第三、

接口类：在类中仅含有纯虚函数的类。这点包含两个信息，其一是只有成员函数，其二是该成员函数都是虚函数。接口类更多是作为一种协议。

接口的使用例子：

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 * 定义射击类：CanShut
 * 定义纯虚函数：aim、reload
 */
class CanShut//接口类，只含有纯虚函数
{
public:
    virtual void aim() =0;
    virtual void reload() =0;//纯虚函数
};

/**
 * 定义枪类：Gun
 * 公有继承射击类
 * 实现成员函数：aim、reload
 */
class Gun : public CanShut
{
public:
    virtual void aim()
    {
         cout << "Gun -- aim" << endl;
    }
    virtual void reload()
    {
         cout << "Gun -- reload" << endl;
    }
};

/**
 * 定义含参函数射击：hunting
 * 调用参数的aim与reload函数
 */
void hunting(CanShut *s)<span style="display: none; width: 0px; height: 0px;" id="transmark"></span>
{
    s->aim();
    s->reload();
}

int main(void)
{
    // 实例化枪对象
    CanShut *g1=new Gun;
    // 调用含参函数hunting,将对象枪传入函数中
    hunting(g1);
    // 释放内存
    delete g1;
    g1=NULL;

    return 0;
}