本文章部分内容源于《黑马程序员C++ 核心篇》
1. 前言
突发奇想来回顾一下多态,顺便把继承和智能指针一起练习一下。多态的出现就是为了在封装和继承类以后,使调用类的时候更宽泛,把类里面的东西再向下一个类里面细分,最后再调用大类的时候,就可以将子类实现的功能一起搞出来。
众所周知多态的实现条件有两个:
- 有继承关系
- 子类重写父类中的虚函数
注意在子类重写父类成员函数(虚函数/纯虚函数)时,virtual可以省略,写了也没啥问题,我下面的代码里都没写。
多态使用时:父类指针或引用指向子类对象。因此这里涉及到new,就需要用delete,由于防止出问题,我会把其中两个例子直接使用智能指针解决shared_ptr。每一个例子都很好,建议挨个刷。
2. TEST1
动物说话,其实父类虚函数没有任何作用,因为最后都要在子类重写,所以后面被纯虚函数替代了。
#include <iostream>
using namespace std;
class Animal
{
public:
virtual void speak()
{
cout << "动物在说话" << endl;
}
};
class Dog : public Animal
{
public:
void speak()
{
cout << "狗狗在说话" << endl;
}
};
class Cat : public Animal
{
public:
void speak()
{
cout << "猫咪在说话" << endl;
}
};
void DoSpeak(Animal& animal)
{
animal.speak();
}
int main()
{
Dog dog;
DoSpeak(dog);
}
3. TEST2
注意:相同类型的指针重复使用的时候,可以省略掉类型。
传统指针实现计算器
#include <iostream>
using namespace std;
class AbstractCalculate
{
public:
virtual int getResult()
{
return 0;
}
int m_Num1;
int m_Num2;
};
class Add : public AbstractCalculate
{
public:
int getResult()
{
return m_Num1+m_Num2;
}
};
class Cut : public AbstractCalculate
{
public:
int getResult()
{
return m_Num1-m_Num2;
}
};
class Mu : public AbstractCalculate
{
public:
int getResult()
{
return m_Num1*m_Num2;
}
};
void test()
{
AbstractCalculate * t = new Add;
t->m_Num1 = 10;
t->m_Num2 = 10;
cout << t->getResult() << endl;
delete t;
t = new Cut;
t->m_Num1 = 10;
t->m_Num2 = 10;
cout << t->getResult() << endl;
delete t;
t = new Mu;
t->m_Num1 = 10;
t->m_Num2 = 10;
cout << t->getResult() << endl;
delete t;
}
int main()
{
test();
}
4. TEST3
注意:声明智能指针,可以用boost::shared_ptr或者std::shared_ptr,都可以
传统指针or智能指针 实现计算器
#include <iostream>
using namespace std;
#include <boost/smart_ptr.hpp>
class Calculate
{
public:
virtual int getResult()
{
return 0;
}
int m_Num1;
int m_Num2;
};
class Add : public Calculate
{
public:
int getResult()
{
return m_Num1+m_Num2;
}
};
void test()
{
// Calculate * t = new Add;
// t->m_Num1 =10;
// t->m_Num2 = 10;
// cout << t->getResult() << endl;
// delete t;
shared_ptr <Calculate> t (new Add); //智能指针
t->m_Num1 =10;
t->m_Num2 = 10;
cout << t->getResult() << endl;
cout <<"----" <<endl;
}
int main()
{
test();
}
5. TEST4
建议还是要先捋一下逻辑再开始写代码,代码写到这需要对应逻辑了。还有就是到目前为止,咱们都没有涉及到构造函数的调用,从下个例子开始进入构造函多态的篇章,一定要好好看。
#include <iostream>
using namespace std;
//烧水 冲炮 倒入杯中 加入辅料 规定流程
class Abstract
{
public:
//shaoshui
virtual void shaoshui() = 0;
//chongpao
virtual void chongpao() = 0;
//daoru
virtual void daoru() = 0;
//fuliao
virtual void fuliao() = 0;
//guiding
void guiding()
{
shaoshui();
chongpao();
daoru();
fuliao();
}
};
//果汁
class orige : public Abstract
{
public:
void shaoshui()
{
cout << "烧水" << endl;
}
void chongpao()
{
cout << "冲泡果汁" << endl;
}
void daoru()
{
cout << "果汁倒入杯里" << endl;
}
void fuliao()
{
cout << "加入果汁粉" << endl;
}
};
//咖啡ie
class coffee : public Abstract
{
public:
void shaoshui()
{
cout << "烧水" << endl;
}
void chongpao()
{
cout << "冲泡咖啡" << endl;
}
void daoru()
{
cout << "咖啡倒入杯里" << endl;
}
void fuliao()
{
cout << "加入咖啡粉" << endl;
}
};
void test()
{
Abstract* t = new coffee;
t->guiding();
delete t;
t = new orige;
t->guiding();
delete t;
}
int main()
{
test();
}
6. TEST5
class Animal {
public:
Animal()
{
cout << "Animal 构造函数调用!" << endl;
}
virtual void Speak() = 0;
//析构函数加上virtual关键字,变成虚析构函数
//virtual ~Animal()
//{
// cout << "Animal虚析构函数调用!" << endl;
//}
virtual ~Animal() = 0;
};
Animal::~Animal()
{
cout << "Animal 纯虚析构函数调用!" << endl;
}
//和包含普通纯虚函数的类一样,包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。
class Cat : public Animal {
public:
Cat(string name)
{
cout << "Cat构造函数调用!" << endl;
m_Name = new string(name);
}
virtual void Speak()
{
cout << *m_Name << "小猫在说话!" << endl;
}
~Cat()
{
cout << "Cat析构函数调用!" << endl;
if (this->m_Name != NULL) {
delete m_Name;
m_Name = NULL;
}
}
public:
string *m_Name;
};
void test01()
{
Animal *animal = new Cat("Tom");
animal->Speak();
//通过父类指针去释放,会导致子类对象可能清理不干净,造成内存泄漏
//怎么解决?给基类增加一个虚析构函数
//虚析构函数就是用来解决通过父类指针释放子类对象
delete animal;
}
int main() {
test01();
system("pause");
return 0;
}
7. TEST6(终极)
建议:先看一遍把逻辑画个图,不然写着写着晕了
#include <iostream>
using namespace std;
#include <boost/smart_ptr.hpp>
//cpu 显卡 内存条 ------ 一堆父类,每一个类会被两个厂家继承,并在厂家继承的类里重写虚函数
class CPU
{
public:
virtual void cpu()=0;
};
class Show
{
public:
virtual void show()=0;
};
class Memory
{
public:
virtual void memory()=0;
};
//定义了电脑类,最后所有东西都会在这里实现,它知识一个普通的类,只不过它的参数来源于各个创建类
//并且要对它的构造函数和析构函数进行声明。请务必记住构造函数的作用是为了初始化参数。
//然后在这里初始化构造函数用了两种方法都可以,读者可以取消注释就ok,
//就是一个形参后面初始化或者函数体内初始化
class Computer
{
public:
// Computer(CPU* _cpu, Show* _show, Memory* _memory)
// {
// m_cpu = _cpu;
// m_show = _show;
// m_memory = _memory;
// }
Computer(CPU *_cpu, Show* _show, Memory* _memory):m_cpu(_cpu), m_show(_show), m_memory(_memory)
{
}
//这个work很重要,后面就要用这个函数实现功能,这三个函数的接口接到了每个子类里面去。因为是*_cpu指针传递进来的,然后它属于CPU这个类,同时在子类里进行了重写,所以调用的时候就接到了子类比如IntelCPU或者LenvoCPU,而真正接到哪个CPU子类,要看在实现多态时候new的哪个类。
void work()
{
m_cpu->cpu();
m_show->show();
m_memory->memory();
}
~Computer()
{
if(m_cpu !=NULL)
{
delete m_cpu;
m_cpu = NULL;
}
if(m_show !=NULL)
{
delete m_show
m_show = NULL;
}
if(m_memory !=NULL)
{
delete m_memory;
m_memory = NULL;
}
}
private:
//隐式声明,注意这里声明的就是实参了S
CPU * m_cpu;
Show * m_show;
Memory* m_memory;
};
//6种情况,是头三个类的多态
class IntelCpu : public CPU
{
public:
void cpu()
{
cout << "Intel牌Cpu开始运行" << endl;
}
};
class IntelShow: public Show
{
public:
void show()
{
cout << "Intel牌Show开始运行" << endl;
}
};
class IntelMemory: public Memory
{
public:
void memory()
{
cout << "Intel牌Memory开始运行" << endl;
}
};
class LenvoCpu : public CPU
{
public:
void cpu()
{
cout << "Lenvo牌Cpu开始运行" << endl;
}
};
class LenvoShow: public Show
{
public:
void show()
{
cout << "Lenvo牌Show开始运行" << endl;
}
};
class LenvoMemory: public Memory
{
public:
void memory()
{
cout << "Lenvo牌Memory开始运行" << endl;
}
};
//重点来了,这里首先通过三个指针,完成cpu、显示器和内存条的多态,也就是在这里你要选择究竟用哪一种硬件。
//三个指针结束之后,还需要对电脑这个类进行指针传递参数,这时候就可以有一个发挥(其实上一步也可以)
//就是对Computer构造函数的一个初始化,你可以用传统指针传递com,初始化后访问;也可以声明类对象的方式
//对类对象初始化,然后访问;也可以智能指针声明的同时对其进行初始化。
//最后要注意的一个点就是,普通类用“.”访问类对象的成员函数,指针类用“->”访问成员函数。
void test()
{
CPU * cpu1 = new IntelCpu;
Show * show1 = new LenvoShow;
Memory * mem1 = new IntelMemory;
cout << "第一个电脑:" << endl;
//这里要在类下面建立一个对象,然后把对象赋值,赋值的是上面的参数
// Computer * com = new Computer(cpu1, show1, mem1);
// com->work();
// delete com;
// Computer tt(cpu1, show1, mem1); //直接创建对象时候要对它进行初始化
// tt.work();
boost::shared_ptr<Computer> test ( new Computer(cpu1, show1, mem1));
test->work();
}
int main()
{
test();
cout << "--3-" << endl;
}