多态
7.1 多态的基本概念
多态是C++面向对象三大特性之一
多态分为两类
- 静态多态:函数重载和运算符重载属于静态多态,复用函数名
- 动态多态:派生类和虚函数实现运行时多态
静态多态和动态多态的区别:
- 静态多态的函数的地址是早绑定,编译阶段确定函数地址
- 动态多态的函数地址晚绑定,运行阶段确定函数地址
#include<iostream>
using namespace std;
class Animal
{
public:
virtual void Speak()
{
cout << "动物在说话" << endl;
}
};
class Cat :public Animal
{
public:
void Speak()
{
cout << "小猫在说话" << endl;
}
};
class Dog :public Animal
{
public:
void Speak()
{
cout << "小狗在说话" << endl;
}
};
//执行说话函数,地址早绑定,在编译阶段确定函数地址
//想执行让猫说话,让说话函数DoSpeak(Animal &animal)晚绑定,需要在运行阶段进行绑定,地址晚绑定
void DoSpeak(Animal &animal) // Animal &animal =cat; 允许父类对象指向子类对象
{
animal.Speak();
}
void Test01()
{
Cat cat;
DoSpeak(cat);
Dog dog;
DoSpeak(dog);
}
int main()
{
Test01();
system("pause");
}
输出结果:
动态多态满足条件:
- 1、有继承关系
- 2、子类重写父类的虚函数 (重写指的是返回值类型、函数名以及参数列表完全相同)
7.2 多态原理剖析
Animal类内部结构:
Animal类内有一个虚函数指针,指向父类的虚函数表(一个指针占4字节的空间)
class Animal
{
public:
virtual void Speak()
{
cout << "动物在说话" << endl;
}
};
Cat类内部结构:
当子类重写父类的虚函数时,子类的虚函数表内部会替换成子类的虚函数地址
class Cat :public Animal
{
public:
void Speak()
{
cout << "小猫在说话" << endl;
}
};
而当子类没有重写父类的虚函数时,此时Cat类的内部结构为:
此时子类的虚函数表中为父类的虚函数地址。
当父类的指针或者引用指向子类对象,发生多态
void DoSpeak(Animal &animal)
{
animal.Speak();
}
7.3 多态案例——计算器类
多态的优点:
- 1、代码组织结构清晰
- 2、可读性强
- 3、利于前期和后期扩展和维护
#include<iostream>
using namespace std;
class AbstractCalculator
{
public:
virtual int GetResult()
{
return 0;
}
int m_num1_;
int m_num2_;
};
//加法计算器
class AddCalculator : public AbstractCalculator
{
public:
virtual int GetResult() //重写父类虚函数
{
return m_num1_ + m_num2_;
}
};
//减法计算器
class SubCalculator : public AbstractCalculator
{
public:
virtual int GetResult() //重写父类虚函数
{
return m_num1_ - m_num2_;
}
};
//乘法计算器
class MulCalculator : public AbstractCalculator
{
public:
virtual int GetResult() //重写父类虚函数
{
return m_num1_ * m_num2_;
}
};
void Test01()
{
//多态使用条件
//父类指针指向子类对象
//加法运算
AbstractCalculator* sum = new AddCalculator;
sum->m_num1_ = 100;
sum->m_num2_ = 200;
cout << sum->m_num1_ << "+" << sum->m_num2_ << "=" << sum->GetResult() << endl;
delete sum;
sum = new SubCalculator;
sum->m_num1_ = 100;
sum->m_num2_ = 200;
cout << sum->m_num1_ << "-" << sum->m_num2_ << "=" << sum->GetResult() << endl;
sum = new MulCalculator;
sum->m_num1_ = 100;
sum->m_num2_ = 200;
cout << sum->m_num1_ << "*" << sum->m_num2_ << "=" << sum->GetResult() << endl;
}
int main()
{
Test01();
system("pause");
}
输出结果:
在真实开发中,提倡开闭原则
开闭原则:对扩展进行开放,对修改进行关闭
7.4 纯虚函数和抽象类
在多态中,通常父类中虚函数的实现是毫无意义的,主要都是调用子类重写的内容,因此可以将虚函数改为纯虚函数
纯虚函数语法:virtual 返回值类型 函数名 (参数列表) = 0;
当类中有了纯虚函数。这个类也称为抽象类
抽象类特点:
- 1、无法实例化对象
- 2、子类必须重写抽象类中的纯虚函数,否则也属于抽象类,无法实例化对象
#include<iostream>
using namespace std;
class Base
{
public:
//纯虚函数,只要有一个纯虚函数,这个类称为抽象类
//抽象类特点:
//1、无法实例化对象
//2、抽象类的子类,必须重写父类中的纯虚函数,否则也属于抽象类
virtual void func() = 0;
};
class Son :public Base
{
public:
virtual void func()//子类必须重写父类中的纯虚函数,否则无法实例化对象
{
cout << "子类中func()函数的调用" << endl;
}
};
void Test01()
{
//Base b; //无法实例化对象
//new Base; //无法实例化对象
Son s; //子类必须重写父类中的纯虚函数,否则无法实例化对象
Base* base = new Son;
base->func();
}
int main()
{
Test01();
system("pause");
}
输出结果:
7.5 多态案例——制作饮品
#include<iostream>
using namespace std;
class AbstractDrink
{
public:
//煮水
virtual void Boil() = 0;
//冲泡
virtual void Brew() = 0;
//倒入杯中
virtual void PourInCup() = 0;
//加入辅料
virtual void PutSomething() = 0;
//制作饮品
void MakeDrink()
{
Boil();
Brew();
PourInCup();
PutSomething();
}
};
class Coffee :public AbstractDrink
{
public:
//煮水
virtual void Boil()
{
cout << "煮水" << endl;
}
//冲泡
virtual void Brew()
{
cout << "冲泡咖啡" << endl;
}
//倒入杯中
virtual void PourInCup()
{
cout << "倒入杯中" << endl;
}
//加入辅料
virtual void PutSomething()
{
cout << "加入糖和牛奶" << endl;
}
};
class Tea : public AbstractDrink
{
public:
//煮水
virtual void Boil()
{
cout << "煮水" << endl;
}
//冲泡
virtual void Brew()
{
cout << "冲泡茶叶" << endl;
}
//倒入杯中
virtual void PourInCup()
{
cout << "倒入杯中" << endl;
}
//加入辅料
virtual void PutSomething()
{
cout << "加入枸杞" << endl;
}
};
void DoWork(AbstractDrink* ab)
{
ab->MakeDrink();
}
void Test01()
{
cout << "制作咖啡" << endl;
DoWork(new Coffee);
cout << "--------------" << endl;
cout << "制作茶" << endl;
DoWork(new Tea);
}
int main()
{
Test01();
system("pause");
}
输出结果:
7.6 虚析构与纯虚析构
多态使用时,如果子类中有属性开辟到堆区,那么父类指针在释放时,那么父类指针在释放时无法调用到子类的析构函数
解决方法:将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性:
- 1、可以解决父类指针释放子类对象
- 2、都需要具体的函数实现
虚析构和纯虚析构的区别:
- 如果该类有纯虚析构,该类是抽象类,无法实例化对象
虚析构语法:
virtual ~类名(){}
纯虚析构语法:
virtual ~类名() = 0;
#include<iostream>
using namespace std;
class Animal
{
public:
Animal()
{
cout << "Animal构造函数的调用" << endl;
}
virtual ~Animal()//虚析构,可以解决父类指针释放对象时不干净的问题
{
cout << "Animal析构函数的调用" << endl;
}
virtual void Speak() = 0;
};
class Cat : public Animal
{
public:
Cat(string name)
{
m_name_ = new string(name);
cout << "Cat构造函数的调用" << endl;
}
void Speak()
{
cout <<*m_name_<< "小猫在说话" << endl;
}
~Cat()
{
if (m_name_ != NULL)
{
delete m_name_;
m_name_ = NULL;
cout << "Cat析构函数的调用" << endl;
}
}
string* m_name_;
};
void Test01()
{
Animal* animal = new Cat("Tom");
animal->Speak();
//父类指针在析构的时候,不会调用子类中的析构函数,导致子类如果有堆区数据,出现内存泄漏
delete animal;
}
int main()
{
Test01();
system("pause");
}
输出结果:
当采用纯虚析构函数时:
class Animal
{
public:
Animal()
{
cout << "Animal构造函数的调用" << endl;
}
//virtual ~Animal()//虚析构,可以解决父类指针释放对象时不干净的问题
//{
// cout << "Animal析构函数的调用" << endl;
//}
virtual void Speak() = 0;
virtual ~Animal() = 0;
};
Animal::~Animal()
{
cout << "Animal纯虚析构的调用" << endl;
}
输出结果:
纯虚析构需要声明也需要实现,因为父类指针释放时需要实现一些功能
总结:
- 1、虚析构或纯虚析构就是用来解决父类指针释放子类对象
- 2、如果子类中没有堆区数据,可以不用写虚析构或纯虚析构
- 3、拥有纯虚析构的类也属于抽象类