创造型设计模式-----工厂方法模式

工厂方法的作用是创造对象（生成产品），用来从一组实现特定逻辑的类中实例化某个对象。（多用于日志功能）

产品类：定义了工厂方法创建的对象接口

具体产品类：实现了产品类的接口

工厂类：创建产品类，声明工厂方法，返回一个产品类对象

具体工厂类：重写用于具体产品类对象的方法

例子

#include<iostream>
#include<stdio.h>
using namespace std;
class product {

public:
    product();
    ~product();
public:
    virtual void productMethod() = 0;
};

class productA :public product {
public:
    productA();
    ~productA();
    void productMethod();
};

class productB :public product {
public:
    productB();
    ~productB();
    void productMethod();
};

#include "Product.h"

using namespace std;

product::product() {

}
product::~product() {

}

productA::productA() {

}

productA::~productA() {

}
productB::productB() {

}
productB::~productB() {

}
void productA::productMethod() {
    cout << "I am product A" << endl;
}

void productB::productMethod() {
    cout << "I am product B" << endl;
}

#include <stdio.h>
#include<iostream>
#include"Product.h"
using namespace std;
class Factory {
public:
    Factory();
    ~Factory();
    virtual product* createProduct(int type) = 0;
};

class FactoryA :public Factory {
public:
    FactoryA();
    ~FactoryA();
    product* createProduct(int type);
};
class FactoryB :public Factory {
public:
    FactoryB();
    ~FactoryB();
    product* createProduct(int type);
};

#include "Factory.h"
#include "Product.h"
using namespace std;
Factory::Factory() {

}
Factory::~Factory() {

}

FactoryA::FactoryA() {

}
FactoryA::~FactoryA() {

}

product* FactoryA::createProduct(int type) {
    product* _product = NULL;
    switch (type)
    {
    case 1:
        _product = new productA();
        break;
    case 2:
        _product = new productB();
        break;
    default:
        break;
    }
    return _product;
}
FactoryB::FactoryB() {

}
FactoryB::~FactoryB() {

}

product* FactoryB::createProduct(int type) {
    product* _product = NULL;
    switch (type)
    {
    case 1:
        _product = new productA();
        break;
    case 2:
        _product = new productB();
        break;
    default:
        break;
    }

    return _product;
}

#include "Factory.h"

using namespace std;

int main(int agrc, char* argv[]) {
    Factory* factory = new FactoryA();
    product* _pro = factory->createProduct(1);
    _pro->productMethod();

    delete _pro;
    _pro = NULL;

    system("pause");
}

下面以宠物为例：

#include<iostream>
#include<stdio.h>
#include<string>
using namespace std;
class Pet {
public:
    Pet();
    ~Pet();
public:
    virtual string  petSound() = 0;
};

class Dog :public Pet {
public:
    Dog();
    ~Dog();
    string petSound();
};

class Cat :public Pet {
public:
    Cat();
    ~Cat();
    string petSound();
};

class Duck :public Pet {
public:
    Duck();
    ~Duck();
    string petSound();
};

#include "Product.h"

using namespace std;

Pet::Pet() {

}
Pet::~Pet() {

}

Dog::Dog() {

}

Dog::~Dog() {

}
string Dog::petSound() {
    return "Dog-->Wang Wang....";
}

Cat::Cat() {

}
Cat::~Cat() {

}

string Cat::petSound() {
    return "Cat-->Miao miao....";
}
Duck::Duck() {

}
Duck::~Duck() {

}

string Duck::petSound() {
    return "Duck-->Ga ga....";
}

#include <stdio.h>
#include<iostream>
#include"Product.h"
using namespace std;

#ifdef Simple_Factoy
class PetFactory {
public:
    PetFactory();
    ~PetFactory();
    virtual Pet* createPet(int type) = 0;
};

class simPetFactory :public PetFactory {
public:
    simPetFactory();
    ~simPetFactory();
    Pet* createPet(int type);
};

#else
class petFactory {
public:
    petFactory();
    ~petFactory();
    virtual Pet* _createPet() = 0;
};

class FactoryDog :public petFactory {
public:
    FactoryDog();
    ~FactoryDog();
    Pet* _createPet();
};
class FactoryCat :public petFactory {
public:
    FactoryCat();
    ~FactoryCat();
    Pet* _createPet();
};
class FactoryDuck :public petFactory {
public:
    FactoryDuck();
    ~FactoryDuck();
    Pet* _createPet();
};
#endif

#include "Factory.h"
#include "Product.h"
using namespace std;
#ifdef Simple_Factoy
PetFactory::PetFactory() {

}
PetFactory::~PetFactory() {

}
simPetFactory::simPetFactory() {

}
simPetFactory::~simPetFactory() {

}

Pet* simPetFactory::createPet(int type) {
    Pet* pet = NULL;
    switch (type)
    {
    case 1:
        pet = new Dog();
        break;
    case 2:
        pet = new Cat();
        break;
    case 3:
        pet = new Duck();
        break;
    default:
        break;
    }
    return pet;
}

#else
petFactory::petFactory() {

}
petFactory::~petFactory() {

}

FactoryDog::FactoryDog() {

}
FactoryDog::~FactoryDog() {

}

Pet* FactoryDog::_createPet() {
    return (new Dog());
}

FactoryCat::FactoryCat() {

}
FactoryCat::~FactoryCat() {

}
Pet* FactoryCat::_createPet() {
    return (new Cat());
}

FactoryDuck::FactoryDuck() {

}
FactoryDuck::~FactoryDuck() {

}

Pet* FactoryDuck::_createPet() {
    return (new Duck());
}
#endif

#include "Factory.h"
#define Simple_Factoy
using namespace std;

int main(int agrc, char* argv[]) {
#ifdef Simple_Factoy
    PetFactory* petfactory = new simPetFactory();
    Pet* pet = petfactory->createPet(2);
    string str = pet->petSound();
    cout << "Pet: " << str << endl;
#else
    petFactory* petfactory = new FactoryDuck();
    Pet* pet = petfactory->_createPet();
    string str = pet->petSound();
    cout << "Pet: " << str << endl;
#endif
    system("pause");
}

若#define Simple_Factoy则定义了简单工厂模式，未遵循开放-封闭原则

如图:

执行结果：

 

若未定义则执行工厂方法模式遵循开放-封闭原则

如图：

执行结果：