C++工厂模式

 1.简单工厂模式

简单工厂模式实现要点

1. 是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类
2. 所有产品类均继承同一个父类
3. 调用者不关心创建产品的细节，只关心产品的品牌

//抽象产品类
class Product
{
public:
    virtual void MethodName()
    {
        //公共方法的实现
    }
    virtual void work() = 0;
    //声明抽象业务方法
};

//具体产品类
class ConcreteProductA : public Product
{
public:
    void MethodName()
    {
        cout << "这是产品A!!!" << endl;
    }

    void work()
    {
        //业务方法的实现
        cout << "这是产品A的功能！！！" << endl;
    }
};

//具体产品类
class ConcreteProductB : public Product
{
public:
    void MethodName()
    {
        cout << "这是产品B!!!" << endl;
    }

    void work()
    {
        //业务方法的实现
        cout << "这是产品B的功能！！！" << endl;
    }
};

//抽象工厂类
class Factory
{
public:
    static Product* GetProduct(string arg)
    {
        //抽象的产品类可以后面在确定具体的生产产品
        Product* product = nullptr;
        if (arg == "A")
        {
            product = new ConcreteProductA();
           
        }
        else if (arg == "B")
        {
            product = new ConcreteProductB();
            
        }
        else
        {
            cout << "生产其他产品！！！" << endl;
        }

        return product;
    }
};

问题1：上面使用static是为了保证只有一个工厂类吗

是的，使用Factory类中的静态方法确保只有一个Factory类的实例，并允许客户端访问工厂方法而无需创建多个Factory类的实例。这是一种常见的设计模式，称为工厂方法模式，其中一个类提供了一个用于创建对象的方法，而不指定将创建的对象的确切类。这有助于在创建对象的集中地点和管理不同类型的对象而不将创建逻辑暴露给客户端代码。

 2.工厂方法模式

工厂方法模式实现要点

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。其基本结构如下。

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
2. 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

//工厂方法模式则有 抽象产品类，具体产品类，抽象工厂类，具体工厂类

//抽象产品类
class Product
{
public:
    virtual void MethodName()
    {
        //公共方法的实现
    }
    virtual void work() = 0;
    //声明抽象业务方法
};

class ConcreteProductA : public Product
{
public:
    void MethodName()
    {
        cout << "这是产品A！！！" << endl;
    }

    void work()
    {
        //业务方法的实现
        cout << "这是产品A实现方法！！！" << endl;
    }
};

class ConcreteProductB : public Product
{
public:
    void MethodName()
    {
        cout << "这是产品B!!!" << endl;
    }

    void work()
    {
        //业务方法的实现
        cout << "这是产品B实现方法!!!" << endl;
    }
};

class FactoryBase//抽象工厂类
{
public:
    FactoryBase() {}
    ~FactoryBase() {}

    virtual Product* GetProduct() = 0;
};


//具体工厂A
class AFactory : public FactoryBase
{
public:
    AFactory() {}
    ~AFactory() {}

    Product* GetProduct()
    {
        return new ConcreteProductA();
    }
};

//具体工厂B
class BFactory : public FactoryBase
{
public:
    BFactory() {}
    ~BFactory() {}

    Product* GetProduct()
    {
        return new ConcreteProductB();
    }
};

3.抽象工厂模式

 抽象工厂模式实现要点

工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。其基本结构如下。

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
2. 具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
3. 多个同族抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
4. 多个同族具体产品（ConcreteProduct）：它是具体产品继承的父类或者是实现的接口。

//抽象工厂模式包含：抽象产品类，具体产品类，抽象工厂类，具体工厂类

class Product
{
public:
	//抽象出产品有哪些功能
	virtual void Name()//产品名字
	{

	}
	virtual void Function()//产品功能
	{

	}
};

//具体产品类
class ProductA:public Product
{
public:
	//重写父类公共函数
	void Name()
	{
		cout << "这是产品A!!!" << endl;
	}

	void Function()
	{
		cout << "这是产品A的功能！！！" << endl;
	}

};
//具体产品类
class ProductB :public Product
{
public:
	//重写父类公共函数
	void Name()
	{
		cout << "这是产品B!!!" << endl;
	}

	void Function()
	{
		cout << "这是产品B的功能！！！" << endl;
	}

};

//抽象工厂类
class Factory
{
public:
	//工厂必然能生产产品
	virtual ProductA* GetProductA() = 0;//纯虚函数
	
	virtual ProductB* GetProductB() = 0;
};

//具体工厂类
class FactoryA
{
public:
	//主要生产产品A
	virtual ProductA* GetProductA()
	{
		//返回有实际空间的产品
		return new ProductA();
	}

	virtual ProductB* GetProductB()
	{
		//返回有实际空间的产品
		return new ProductB();
	}
};

//具体工厂类
class FactoryB
{
public:
	virtual ProductA* GetProductA()
	{
		//返回有实际空间的产品
		return new ProductA();
	}

	//主要生产产品B
	virtual ProductB* GetProductB()
	{
		//返回有实际空间的产品
		return new ProductB();
	}
};

int main()
{

	ProductA* ptrA = nullptr;
	ProductB* ptrB = nullptr;

	Factory* factoryA =(Factory*) new FactoryA();
	Factory* factoryB = (Factory*) new FactoryB();

	ptrA = factoryA->GetProductA();
	ptrA->Name();
	ptrA->Function();

	ptrB = factoryB->GetProductB();
	ptrB->Name();
	ptrB->Function();

	system("pause");
	return 0;
}