C++学习笔记（十三）动态多态、虚函数

#include <iostream>

using namespace std;

// 基类
class Animal
{
public:
void eat()
{
cout << "动物吃饭" << endl;
}

// 虚函数
virtual void sleep()
{
cout << "动物睡觉" << endl;
}
};

class Cat :public Animal
{
public:
// 函数 重定义
void eat()
{
cout << "猫 吃  鱼" << endl;
}

// 虚函数 的重定义  =====>  函数重写
void sleep()
{
cout << "猫 趴着睡觉" << endl;
}
};

class Fish :public Animal
{
public:
// 函数 重定义
void eat()
{
cout << "鱼 吃 虾" << endl;
}

// 函数 重定义
void sleep()
{
cout << "鱼 睁着眼睡觉" << endl;
}
};

// 基类指针
// 期望做的事情：同样的调用语句
// 1、当基类指针指向基类对象的时候，调用基类自己的成员函数
// 2、当基类指针指向派生类对象的时候，调用派生类的同名成员函数

// =====> 多态：一种调用语句有多种不同的表现形态
// =====> 实现：通过 虚函数 来实现   ---> 在函数声明前加 virtua 关键字，该函数就变为虚函数

// 编译阶段：预处理、编译、汇编、链接
void func(Animal *pa)
{
// 指针的行为受限于指针的类型
// pa 是 Animal 类型，所以只能执行 Animal 内部的方法

// 1、判断 pa 的类型        -----> Animal 类型
// 2、判断 eat() 函数类型   -----> 普通函数
// 3、结果：因为是普通函数，则按照指针类型调用 -----> Animal::eat()
// ==========>  在编译期间就已经知道如何处理、如何运行  ------> 静态联编   早期绑定
pa->eat();

// 1、判断 pa 的类型        -----> Animal 类型
// 2、判断 sleep() 函数类型 -----> 是虚函数
// 3、结果：因为是虚函数，所以不知道调用谁的函数 
// -------> 通过某种机制，找到 最终需要调用的函数（和传过来的对象有关）
// ==========>  在编译期间无法知道具体如何处理、在运行的时候根据传入的对象才能确定具体
// 调用          ------> 动态联编   迟绑定
pa->sleep();
}

// 多态实现条件：
// 1、要有继承
// 2、要有虚函数
// 3、要有基类指针指向派生类对象

int main()
{
Animal a;
Cat    c;
Fish   f;
func(&a);

cout << "------------------------" << endl;
func(&c);

cout << "------------------------" << endl;
func(&f);

return 0;
}

int main1()
{
Animal a;
Cat    c;
Fish   f;
a.eat();
a.sleep();

cout << "------------------------" << endl;
c.eat();
c.sleep();

cout << "------------------------" << endl;
f.eat();
f.sleep();

    return 0;
}