工厂模式——简单工厂模式 && 智能指针的使用

概述：

1. 定义：定义一个工厂类，他可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类

2. 在简单工厂模式中用于被创建实例的方法通常为静态(static)方法,因此简单工厂模式又被成为静态工厂方法(Static Factory Method)

3. 需要什么，只需要传入一个正确的参数，就可以获取所需要的对象，而无需知道其实现过程

结构：

1.工厂类(factory)：核心部分，负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象。

2.抽象产品类：工厂类所创建的所有对象的父类，封装了产品对象的公共方法，所有的具体产品为其子类对象。

3.产品类：简单工厂模式的创建目标，所有被创建的对象都是某个具体类的实例。它要实现抽象产品中声明的抽象方法(有关抽象类)。

代码示例：

/*
 * @Description: 
 * @Version: 2.0
 * @Author: 
 * @Date: 2021-02-24 13:58:22
 * @LastEditors:
 * @LastEditTime: 2021-02-24 15:40:50
 */
#include "../common.h"

typedef enum
{
    TYPE_A = 1,
    TYPE_B,
    TYPE_C
}TYPE_FOOD;

//抽象产品类
class CFood
{
public:
    CFood(){showFoodName();};
    virtual void showFoodName(){};
    virtual ~CFood(){};
};

//具体产品类A
class CFood_A : public CFood
{
public:
    CFood_A()
    {
        showFoodName();
    }
    void showFoodName()
    {
        cout << "I'm Food_A" << endl;
    }
    
    ~CFood_A()
    {
        cout << "delete Food_A" << endl;
    }   
};

//具体产品类B
class CFood_B : public CFood
{
public:
    CFood_B()
    {
        showFoodName();
    }
    void showFoodName()
    {
        cout << "I'm Food_B" << endl;
    }   
    ~CFood_B()
    {
        cout << "delete Food_B" << endl;
    }
};

//具体产品类C
class CFood_C : public CFood
{
public:
    CFood_C()
    {
        showFoodName();
    }
    void showFoodName()
    {
        cout << "I'm Food_C" << endl;
    }
    ~CFood_C()
    {
        cout << "delete Food_C" << endl;
    }   
};

//工厂类
class CFoodFactory
{
public:
    CFood *createCFood(TYPE_FOOD type)
    {
        switch(type)
        {
            case TYPE_A:
                return new CFood_A;
                break;
            case TYPE_B:
                return new CFood_B;
                break;
            case TYPE_C:
                return new CFood_C;
                break;
            default:break;
        }
    }
    ~CFoodFactory()
    {
        cout << "delete CFoodFactory" <<endl;
    }
};

int main()
{
    CFoodFactory *foodFactoryPtr = new CFoodFactory();
    CFood *A_foodPtr = foodFactoryPtr -> createCFood(TYPE_A);
    CFood *B_foodPtr = foodFactoryPtr -> createCFood(TYPE_B);
    CFood *C_foodPtr = foodFactoryPtr -> createCFood(TYPE_C);

    delete A_foodPtr;
    delete B_foodPtr;
    delete C_foodPtr;
    delete foodFactoryPtr;
}

结果展示：

I'm Food_A
I'm Food_B
I'm Food_C
delete Food_A
delete Food_B
delete Food_C
delete CFoodFactory

以上代码，如果去掉delete语句，结果：

I'm Food_A
I'm Food_B
I'm Food_C

这就是普通指针的不足之处。

使用unique_ptr智能指针：

unique_ptr实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露(例如“以new创建对象后因为发生异常而忘记调用delete”)特别有用。另外unique_ptr还有更聪明的地方：当程序试图将一个 unique_ptr 赋值给另一个时，如果源 unique_ptr 是个临时右值，编译器允许这么做；如果源 unique_ptr 将存在一段时间，编译器将禁止这么做。

int main()
{

    unique_ptr<CFoodFactory> foodFactoryPtr(new CFoodFactory());
    unique_ptr<CFoodFactory> p2;
    //  p2 = foodFactoryPtr;//会报错

    unique_ptr<CFoodFactory> p3 = unique_ptr<CFoodFactory>(new CFoodFactory());; //正常
}

会正常析构：

delete CFoodFactory
delete CFoodFactory

使用shared_ptr智能指针：

shared_ptr实现共享式拥有概念。多个智能指针可以指向相同对象，该对象和其相关资源会在“最后一个引用被销毁”时候释放。从名字share就可以看出了资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()来查看资源的所有者个数。除了可以通过new来构造，还可以通过传入auto_ptr, unique_ptr,weak_ptr来构造。当我们调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。

代码：

int main()
{
    shared_ptr<CFoodFactory> p1(new CFoodFactory());
    shared_ptr<CFoodFactory> p2 = p1; //允许 
}

结果：

delete CFoodFactory

share_ptr虽然已经很好用了，但是有一点share_ptr智能指针还是有内存泄露的情况，当两个对象相互使用一个shared_ptr成员变量指向对方，会造成循环引用，使引用计数失效，从而导致内存泄漏。

weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的shared_ptr， weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。

暂时不补充其它的代码和介绍。