类 —— 多态、抽象类

多态

通常说的多态,是指发生在类之间的多态。即相同的代码,实现不同的功能。
函数重载 —— 静态多态/编译时多态。
类之间的多态 —— 动态多态/运行时多态。

前提

继承、虚函数、函数重写。

函数重写(override)

在子类中重写父类的虚函数就是函数重写的过程,可以实现多态。
1、必须有继承关系;
2、父类中必须有虚函数。

虚函数(virtual)

只要基类中的某函数是虚函数,则所有继承自此基类的子类中该函数都是虚函数。
只有 普通成员函数 与 析构函数 可以声明为虚函数。

常规来说,给父类中的函数加上 virtual 关键字,定义成一个虚函数,那么在子类中,可以对父类的虚函数进行函数重写(override)。在 C++11中,可以在派生类的新覆盖的函数上使用一个关键字 override 来验证覆盖是否成功。

只要有虚函数的类,都会有一个虚函数表和一个虚(函数表)指针。
虚指针:指向虚函数表的指针;
虚函数表:存储所有的虚函数的信息(每个有虚函数的类都有专属的虚函数表)

虚函数表:保存所有虚函数的入口地址,每一个包含虚函数的类都会有一张虚函数表。
如果发生继承关系,子类会先复制父类的虚函数表,如果子类对某个虚函数重写,就会更新虚函数表中该函数的入口地址。未被重写的虚函数,保持原样(和父类的虚函数一样)。
虚函数表指针:指向虚函数表的指针,父类中有一个虚函数表指针,子类中的虚函数表指针是从父类中继承下来的虚函数表指针,指向子类的虚函数表(虚函数表指针存在类中的第一个位置,占 4 字节)。

#include 
using namespace std;

class Father
{
public:
    string secret;
    virtual void act_1()
    {
        cout << "Earn money. " << endl;
    }
};

class Son:public Father
{
public:
    string secret;
    void act_1() override		// 覆盖基类中的虚函数,virtual 可写可不写,override 验证覆盖是否成功
    {
        cout << "Save money. " << endl;
    }
};

int main()
{
    Father f;
    cout << &f << endl;				// 类中存在虚函数时,起始位置存放虚指针
    cout << &f.secret << endl;		// 类中第一个成员的地址,偏移首地址 4 个字节

    Son s;
    cout << &s << endl;				// 子类继承父类的虚指针(1 个)
    cout << &s.secret << endl;		// 类中第一个成员的地址,偏移首地址 8 个字节

    return 0;
}

类 —— 多态、抽象类_第1张图片

虚析构函数

问题:由于实现多态 需要使用父类的指针 指向 子类的空间,父类指针可以操作的空间只能是父类自己的那部分,所以,在 delete 父类指针时,并不会释放掉子类的空间。
解决方法:给基类(父类)的析构函数前面加上 virtual 关键字,只要基类是虚析构函数,后面继承的所有子类都是虚析构函数,虚析构函数会引导父类的指针释放掉子类的空间。

#include 
using namespace std;

class Father
{
    string secret;
public:
    virtual void act_1();	// 虚函数声明
    
    virtual ~Father()		
    {
        cout << "Destructor of father class. " << endl;
    }
};

void Father::act_1()		// 虚函数声明与定义分离时,virtual 只需要修饰在声明处
{
    cout << "Earn money. " << endl;
}

class Son:public Father
{
    string secret;

public:
    void act_1()			// 前面可以加 virtual,后面可以加 override
    {
        cout << "Save money. " << endl;
    }
    void act_2()			// 这里不能加 virtual 和 override,此函数非虚函数
    {
        cout << "Inherit money. " << endl;
    }
    virtual ~Son()			// 此 virtual 可以不加
    {
        cout << "Destructor of son class. " << endl;
        // 父类的析构前,不加 virtual,则 delete p 时,此函数不执行
    }
};

int main()
{
    Father *p = new Son;
    p->act_1();
    p->Father::act_1();
    delete p;

    return 0;
}

类 —— 多态、抽象类_第2张图片

多态的实现

多态可以理解为”一种接口,多种状态“。只需要编写一个函数接口,根据传入的参数类型,执行不同的策略代码。

多态的使用时需要具有三个前提条件:
● 公有继承
● 函数覆盖
● 基类的 引用/指针 指向派生类对象

在代码运行时,通过对象的虚函数指针找到虚函数表,在表中定位到虚函数的调用地址,从而执行对应的虚函数内容。
使用时会产生一些额外的开销,优点是代码的编写更加灵活高效,缺点是会降低代码的执行速度。

#include 
using namespace std;

class Animal
{
public:
    virtual void eat();
};

// 声明与定义分离。virtual 只需要修饰声明处
void Animal::eat()
{
    cout << "动物爱吃坤柳。" << endl;
}

class Dog:public Animal
{
public:
    // 覆盖基类中虚函数,派生类中 virtual 关键字可写可不写
    void eat() override 		// 验证虚函数覆盖是否成功
    {
        cout << "狗吃骨头。" << endl;
    }
};

class Cat:public Animal
{
public:
    void eat() // override
    {
        cout << "猫吃鱼。" << endl;
    }
};

void test_eat1(Animal &al)			// 基类的引用指向派生类对象
{
    al.eat();		
}

void test_eat2(Animal *al)			// 基类的指针指向派生类对象
{
    al->eat();		
}	

int main()
{
    Animal a1;
    Dog d1;
    Cat c1;
    test_eat1(a1);  		// 动物爱吃坤柳,基类的引用指向了基类的对象
    test_eat1(d1);  		// 狗吃骨头,基类的引用指向了 Dog类 的对象
    test_eat1(c1);  		// 猫吃鱼,基类的引用指向了 Cat类 的对象

    Animal *a2 = new Animal;    // 基类的指针指向了基类的对象
    Dog *d2 = new Dog;
    Cat *c2 = new Cat;
    test_eat2(a2);  // 动物爱吃坤柳
    test_eat2(d2);  // 狗吃骨头
    test_eat2(c2);  // 猫吃鱼

    return 0;
}

类 —— 多态、抽象类_第3张图片

练习

全局变量:int monster = 10000;
定义英雄类 hero,受保护的属性:string name,int hp,int attck;
公有的无参构造,有参构造,虚成员函数 void Atk(){blood-=0;};
法师类继承自英雄类,私有属性 int ap_atk=50;重写虚成员函数 void Atk(){blood-=(attck+ap_atk);};射手类继承自英雄类,私有属性 int ac_atk = 100;重写虚成员函数 void Atk(){blood-=(attck+ac_atk);}实例化类对象,判断怪物何时被杀死。

#include 
using namespace std;

int He_Yanwei = 10000;

class Hero
{
protected:
    string name;
    int hp;
    int attack;
public:
    Hero(string name, int hp, int attack):name(name), hp(hp), attack(attack) { }
    virtual void atk()
    {
        He_Yanwei -= 0;
    }
};

class Mages:public Hero
{
    int ap_atk = 50;
public:
    Mages():Hero("You_Changzhi", 10000000000, 1000) { }
    Mages(string name, int hp, int attack, int ap_atk):Hero(name, hp, attack), ap_atk(ap_atk) { }
    void atk()
    {
        He_Yanwei -= (attack + ap_atk);
        cout << "-" << (attack + ap_atk) << endl;
    }
};

class Shooters:public Hero
{
    int ac_atk = 100;
public:
    Shooters():Hero("Zou_Jinqi", 100000000, 1000) { }
    Shooters(string name, int hp, int attack, int ac_atk):Hero(name, hp, attack), ac_atk(ac_atk) {}
    void atk()
    {
        He_Yanwei -= (attack + ac_atk);
        cout << "-" << (attack + ac_atk) << endl;
    }
};

int main()
{
    Mages mage("You_Changzhi", 10000000000, 1000, 50);
    Shooters shooter("Zou_Jinqi", 100000000, 1000, 100);
    int i = 1;
    cout << "He_Yanwei: " << He_Yanwei << endl;
    cout << "-----------------------" << endl;

    while (He_Yanwei >= 0)
    {
        cout << "Round " << i++ << ": " << endl;

        shooter.atk();
        if (He_Yanwei <= 0)
            break;
        cout << "He_Yanwei: " << He_Yanwei << endl;

        mage.atk();
        if (He_Yanwei <= 0)
            break;
        cout << "He_Yanwei: " << He_Yanwei << endl;

        shooter.atk();
        if (He_Yanwei <= 0)
            break;
        cout << "He_Yanwei: " << He_Yanwei << endl;

        cout << "-----------------------" << endl;
    }
//    cout << "-----------------------" << endl;			// 加上就有问题,离谱
    cout << "You killed He Yanwei! " << endl;

    return 0;
}

类 —— 多态、抽象类_第4张图片

纯虚函数和抽象类

纯虚函数

virtual 返回值 函数名(参数列表) = 0;

抽象类

包含纯虚函数的类就是抽象类,抽象类不允许实例化类对象。抽象类的析构函数必须是虚析构函数。
抽象类通常作为一个类型的模板(作为基类存在),不能实例化类对象(没有意义)。在继承后的子类中,加上具体的属性后,重写父类中的纯虚函数就可以实例化类对象了;如果子类中不重写父类的纯虚函数,那么子类也不能实例化类对象。
抽象类的子类重写纯虚函数:该子类不再是抽象类。(水果 ——> 苹果、香蕉、草莓…)
抽象类的子类不重写纯虚函数:该子类依然是抽象类。(水果 ——> 热带水果、温带水果…)
● 抽象类支持多态,可以存在引用或指针的声明格式。
● 因为抽象类的作用是指定算法框架,因此在一个继承体系中,抽象类的内容相对丰富且重要。

#include 
using namespace std;

class Test
{
public:
    virtual void show() = 0;     		// show 函数是一个纯虚函数
};

class T:public Test
{
public:
    void show()
    {
        cout << "T" << endl;
    }
};

int main()
{
    T t1;			// 可以定义了;若不对 父类的纯虚函数 重写,则此行报错
    
    return 0;
}

练习

定义抽象类 Animal,私有成员 string name,string colour,公有纯虚函数 void sound(),
定义 Cat 类,继承自 Animal 类,重写 sound 函数,
定义 Dog 类,继承自 Animal 类,重写 sound 函数,实现多态现象的测试。
(定义一个全局函数,可以实现两个子类 sound 功能的测试,要求:全局函数只有一个参数)

#include 
using namespace std;

class Animal
{
    string species;
    string color;
public:
    virtual void sound() = 0;
};

class Cat:public Animal
{
public:
    void sound()
    {
        cout << "喵~喵~" << endl;
    }
};

class Dog:public Animal
{
public:
    void sound()
    {
        cout << "汪~汪~" << endl;
    }
};

class Sheep:public Animal				// 1、公有继承
{
public:
    void sound()						// 2、重写父类的虚函数
    {
        cout << "咩~咩~" << endl;
    }
};

void choice(Animal *ani)				
{
    ani->sound();						// 3、基类的 指针或引用 指向 派生类对象
}

int main()
{
    Cat c;
    choice(&c);
    Dog d;
    choice(&d);
    Sheep sh;
    choice(&sh);

    return 0;
}

类 —— 多态、抽象类_第5张图片

你可能感兴趣的:(开发语言,c++)