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;
}