18.C++设计模式-工厂

简单工厂

图片.png

缺点：每增加一种产品就要在工厂中修改

#include <iostream>
using namespace std;

class Fruit {
public:
     virtual void getName() = 0;
};

class Apple : public Fruit {
    void getName() {
        cout<<"我是苹果"<<endl;
    }
};

class Banana : public Fruit {
    void getName() {
        cout<<"我是香蕉"<<endl;
    }
};

class Factory {
public:
    Fruit* create(int num) {
        if (num == 1) {
            return new Apple;
        }
        else if (num == 2) {
            return new Banana;
        }
        else
        {
            cout << "不存在的水果" << endl;
        }
    }
};

void main() {
    Factory* f = new Factory;
    Fruit* fruit = f->create(1);
    fruit->getName();
    delete fruit;

    Fruit* fruit1 = f->create(2);
    fruit1->getName();
    delete fruit1;

    Fruit* fruit2 = f->create(3);
    delete f;
    system("pause");
}

工厂模式

优点：相比于简单工厂模式，将工厂抽象化，更加符合开闭原则，有新的产品加入时，只需要添加新的产品类继承抽象产品，并添加一个本产品工厂继承抽象工厂即可
缺点：在开闭原则下只能生产一种产品，不能生产一个产品组

图片.png

#include <iostream>
using namespace std;

class Fruit {
public:
     virtual void getName() = 0;
};

class Apple : public Fruit {
    void getName() {
        cout<<"我是苹果"<<endl;
    }
};

class Banana : public Fruit {
    void getName() {
        cout<<"我是香蕉"<<endl;
    }
};

class AbstractFactory {
public:
    virtual Fruit* createProduct() = 0;
};

class AppleFactory :public AbstractFactory{
public:
    virtual Fruit* createProduct() {
        return new Apple;
    }
};

class BananaFactory :public AbstractFactory {
public:
    virtual Fruit* createProduct() {
        return new Banana;
    }
};

void main() {
    AbstractFactory* f = NULL;
    Fruit* fruit = NULL;
    
    f = new AppleFactory;
    fruit = f->createProduct();
    fruit->getName();
    delete fruit;
    delete f;

    f = new BananaFactory;
    fruit = f->createProduct();
    fruit->getName();
    delete fruit;
    delete f;

    system("pause");
}

抽象工厂模式

相较于工厂模式，可以生产一个产品组

图片.png

#include <iostream>
using namespace std;

class Fruit {
public:
     virtual void getName() = 0;
};

class NorthApple : public Fruit {
    void getName() {
        cout<<"我是北方苹果"<<endl;
    }
};

class NorthBanana : public Fruit {
    void getName() {
        cout<<"我是北方香蕉"<<endl;
    }
};

class SourthApple : public Fruit {
    void getName() {
        cout << "我是南方苹果" << endl;
    }
};

class SourthBanana : public Fruit {
    void getName() {
        cout << "我是南方香蕉" << endl;
    }
};


class AbstractFactory {
public:
    virtual Fruit* createApple() = 0;
    virtual Fruit* createBanana() = 0;
};

class NorthFactory :public AbstractFactory {
public:
    virtual Fruit* createApple() {
        return new NorthApple;
    }
    virtual Fruit* createBanana() {
        return new NorthBanana;
    }
};

class SourthFactory :public AbstractFactory {
public:
    virtual Fruit* createApple() {
        return new SourthApple;
    }
    virtual Fruit* createBanana() {
        return new SourthBanana;
    }
};

void main() {
    AbstractFactory* f = NULL;
    Fruit* fruit = NULL;
    
    f = new SourthFactory;
    fruit = f->createApple();
    fruit->getName();
    delete fruit;

    fruit = f->createBanana();
    fruit->getName();
    delete fruit;
    delete f;

    f = new NorthFactory;
    fruit = f->createApple();
    fruit->getName();
    delete fruit;

    fruit = f->createBanana();
    fruit->getName();
    delete fruit;

    delete f;
    system("pause");
}