C++设计模式之工厂模式

工厂模式：分为简单工厂模式、工厂模式、抽象工厂模式三个层次

简单工厂模式，通过一个工厂类实现别的类的创建
缺点：
1、增加新的功能时，需要修改源代码，不符合开闭原则
2、一个工厂类职责过重，类发生问题时，会影响很多实用使用该工厂的模块

//抽象水果
class AbstractFruit{
public:
	virtual void Showname() = 0;
}；
//两个具体水果
class Apple: public AbstractFruit{
public:
	virtual void Showname(){
		cout << "我是苹果"<<endl;
	}
};
class Banana: public AbstractFruit{
public:
	virtual void Showname(){
		cout << "我是香蕉"<<endl;
	}
};

//水果工厂
class FruitFactory{
public:
	static AbstractFruict* CreateFruit(string flag){
		if(flag == "apple")
			return new Apple;
		else if(falg == "banana")
			return new Banana;
		else
			return NULL;
	}
};


int main(){
	FruitFactor* factory = new FruitFactory;
	
	AbstactFruit* fruit = factory->CreateFruit("apple");
	fruit->Showname();
	delete fruit;
	
	fruit = factory->CreateFruit("Banana");
	fruit->Showname();
	delete fruit;
	
	delete factory;
	return 0;
}

工厂方法模式：通过抽象工厂指针的多态特性完成不同工厂类函数的调用，不同工厂类完成别的类的创建
好处：符合开闭原则，不需要记住具体类名，可扩展性增强
缺点：类的个数成倍增加（每出现一个新的类，相对应的也会多出一个对应的工厂类），维护成本增加

//抽象水果
class AbstractFruit{
public:
    virtual void Showname() = 0;
};
//两个具体水果
class Apple: public AbstractFruit{
public:
    virtual void Showname(){
        cout << "我是苹果"<<endl;
    }
};
class Banana: public AbstractFruit{
public:
    virtual void Showname(){
        cout << "我是香蕉"<<endl;
    }
};

//抽象工厂类
class AbstractFactory{
public:
    virtual AbstractFruit* CreateFruit() = 0;
};
//两个具体工厂类：
class AppleFactory: public AbstractFactory{
public:
    virtual AbstractFruit* CreateFruit(){
        return new Apple;
    }
};

class BananaFactory: public AbstractFactory{
public:
    virtual AbstractFruit* CreateFruit(){
        return new Banana;
    }
};

int main(){
    AbstractFactory* factory = NULL;
    AbstractFruit* fruit = NULL;

    factory = new AppleFactory;
    fruit = factory->CreateFruit();
    fruit->Showname();

    delete fruit;
    delete factory;

    factory = new BananaFactory;
    fruit = factory->CreateFruit();
    fruit->Showname();

    delete fruit;
    delete factory;

    return 0;
}

抽象工厂模式：针对产品族，不针对产品等级结构
产品族：同一产地或同一厂商，功能不同（如美国产的苹果、香蕉）
产品等级：功能相同，产地或者厂商不同（如美国产的苹果，中国产的苹果）

//抽象苹果
class AbstractApple{
public:
    virtual void showname() = 0;
};
//两个具体苹果
class ChinaApple : public AbstractApple{
public:
    virtual void showname(){
        cout << "中国苹果" <<endl;
    }
};
class USAApple : public AbstractApple{
public:
    virtual void showname(){
        cout << "美国苹果" <<endl;
    }
};
//抽象香蕉
class AbstractBanana{
public:
    virtual void showname() = 0;
};
//两个具体香蕉
class ChinaBanana : public AbstractBanana{
public:
    virtual void showname(){
        cout << "中国香蕉" <<endl;
    }
};
class USABanana : public AbstractBanana{
public:
    virtual void showname(){
        cout << "美国香蕉" <<endl;
    }
};
//抽象工厂：针对产品族
class AbstractFactory{
public:
    virtual AbstractApple* CreateApple() = 0;
    virtual AbstractBanana* CreateBanana() = 0;
};
//两个具体工厂
class ChinaFactory: public AbstractFactory{
public:
    virtual AbstractApple* CreateApple(){
        return new ChinaApple;
    }
    virtual AbstractBanana* CreateBanana(){
        return new ChinaBanana;
    }
};
class USAFactory: public AbstractFactory{
public:
    virtual AbstractApple* CreateApple(){
        return new USAApple;
    }
    virtual AbstractBanana* CreateBanana(){
        return new USABanana;
    }
};

int main(){
    AbstractFactory* factory = NULL;
    AbstractApple* apple = NULL;
    AbstractBanana* banana = NULL;

    factory = new ChinaFactory;
    apple = factory->CreateApple();
    banana = factory->CreateBanana();
    apple->showname();
    banana->showname();

    delete apple;
    delete banana;
    delete factory;

    factory = new USAFactory;
    apple = factory->CreateApple();
    banana = factory->CreateBanana();
    apple->showname();
    banana->showname();

    delete apple;
    delete banana;
    delete factory;

    return 0;
}