工厂模式

简单工厂模式：

#include<iostream>

using namespace std;


class Fruits
{
public:
    Fruits(const string &name)
        :nname(name){}
    virtual  void  Show() = 0;
private:
    string nname;
};


class Apple: public Fruits
{
public:
    Apple(const string &name)
        :Fruits(name){}
    void  Show()
    {
        cout<<"This   is    Apple !"<<endl;
    }
};

class Peach: public Fruits
{
public:
    Peach(const string &name)
        :Fruits(name){}
    void  Show()
    {
        cout<<"This   is    Peach !"<<endl;
    }
};

class  Factory
{
public:
    Fruits *  Production(size_t  ID)
    {
        Fruits * re = NULL;
        switch(ID)
        {
        case 0:
            re = new Peach("peach");
            break;
        case 1:
            re = new Apple("Apple");
            break;
        }
        return re;
    }
};


int main()
{
    Factory  fac;
    Fruits  * it = fac.Production(5);
    if(it)
    {
         it->Show();
    }
    else
    {
        cout<<"没有对应型号产品!"<<endl;
    }
    return 0;
}

***工厂方法模式：**

```cpp
#include<iostream>

using namespace std;

#include<iostream>
#include<string>

class Fruit
{
public:
	Fruit(std::string nm)
		:mname(nm){}
	virtual void operation() = 0;
protected:
	std::string mname;
};

class Apple : public Fruit
{
public:
	Apple(std::string name)
		:Fruit(name){}
	void operation()
	{
		std::cout << "this is an apple!" << std::endl;
	}
};

class Banana : public Fruit
{
public:
	Banana(std::string name)
		:Fruit(name){}
	void operation()
	{
		std::cout << "this is a banana!" << std::endl;
	}
};

class Pear : public Fruit
{
public:
	Pear(std::string name)
		:Fruit(name){}
	void operation()
	{
		std::cout << "this is a pear!" << std::endl;
	}
};

class Factory
{
public:
	Factory(std::string name)
		:mname(name){}
	virtual Fruit* createFruit() = 0;
protected:
	std::string mname;
};

class F1 : public Factory
{
public:
	F1(std::string name)
		:Factory(name){}
	Fruit* createFruit()
	{
		return new Apple("apple");
	}
};

class F2 : public Factory
{
public:
	F2(std::string name)
		:Factory(name){}
	Fruit* createFruit()
	{
		return new Banana("banana");
	}
};

class F3 : public Factory
{
public:
	F3(std::string name)
		:Factory(name){}
	Fruit* createFruit()
	{
		return new Pear("pear");
	}
};


int main()
{
	Factory* pfa = new F2("f3");
	Fruit* pf = pfa->createFruit();
	pf->operation();
	return 0;
}


**抽象工厂模式：
```**

```cpp
#include<iostream>

using namespace std;


class Fruit
{
public:
	Fruit(std::string nm)
		:mname(nm){}
	virtual void operation() = 0;
protected:
	std::string mname;
};

class Apple : public Fruit
{
public:
	Apple(std::string name)
		:Fruit(name){}
	void operation()
	{
		std::cout << "this is an apple!" << std::endl;
	}
};

class Banana : public Fruit
{
public:
	Banana(std::string name)
		:Fruit(name){}
	void operation()
	{
		std::cout << "this is a banana!" << std::endl;
	}
};

class Pear : public Fruit
{
public:
	Pear(std::string name)
		:Fruit(name){}
	void operation()
	{
		std::cout << "this is a pear!" << std::endl;
	}
};

class Fruit_knife
{
public:
	Fruit_knife(std::string nm)
		:mname(nm){}
	virtual void operation() = 0;
protected:
	std::string mname;
};

class Apple_knife : public Fruit_knife
{
public:
	Apple_knife(std::string name)
		:Fruit_knife(name){}
	void operation()
	{
		std::cout << "this is an apple_knife!" << std::endl;
	}
};

class Banana_knife : public Fruit_knife
{
public:
	Banana_knife(std::string name)
		:Fruit_knife(name){}
	void operation()
	{
		std::cout << "this is a banana_knife!" << std::endl;
	}
};

class Pear_knife : public Fruit_knife
{
public:
	Pear_knife(std::string name)
		:Fruit_knife(name){}
	void operation()
	{
		std::cout << "this is a pear_knife!" << std::endl;
	}
};


class Factory
{
public:
	Factory(std::string name)
		:mname(name){}
	virtual Fruit* createFruit() = 0;
    virtual Fruit_knife* createFruit_knife() = 0;
protected:
	std::string mname;
};

class F1 : public Factory
{
public:
	F1(std::string name)
		:Factory(name){}
	Fruit* createFruit()
	{
		return new Apple("apple");
	}
    Fruit_knife* createFruit_knife()
	{
		return new Apple_knife("apple");
	}
};

class F2 : public Factory
{
public:
	F2(std::string name)
		:Factory(name){}
	Fruit* createFruit()
	{
		return new Banana("banana");
	}
    Fruit_knife* createFruit_knife()
	{
		return new Banana_knife("apple");
	}
};

class F3 : public Factory
{
public:
	F3(std::string name)
		:Factory(name){}
	Fruit* createFruit()
	{
		return new Pear("pear");
	}

    Fruit_knife* createFruit_knife()
	{
		return new Pear_knife("apple");
	}
};


int main()
{
	Factory* pfa = new F2("f3");
	Fruit* pf = pfa->createFruit();
    Fruit_knife* pfk = pfa->createFruit_knife();
	pf->operation();
    pfk->operation();
	return 0;
}