例項1

#include <iostream>

using namespace std;

class Base  //基類
{
public:
    virtual void print()
    {
        cout << "Base show()" << endl;
    };
};

class Derived_A : public Base   //派生類A
{
public:
    void print()
    {
        cout << "Derived_A show()" << endl;
    };
};

class Derived_B : public Base   //派生類B
{
public:
    void print()
    {
        cout << "Derived_B show()" << endl;
    };
};

class Factory   //工廠
{
public:
    Base *CreateApi( int flag );
};

Base *Factory::CreateApi( int flag )
{
    if( 1 == flag )
    {
        return new Derived_A();
    }
    else if ( 2 == flag )
    {
        return new Derived_B();
    }
}

Base *CreateProduction( int flag )
{
    if( 1 == flag )
    {
        return new Derived_A();
    }
    else if ( 2 == flag )
    {
        return new Derived_B();
    }
}

int    main()
{
    Base *p = NULL;
    //Factory f;

//    p = f.CreateApi( 1 );
    p = CreateProduction( 1 );

    p->print();
}
 

例項2

#include<iostream>
#include<string>

using namespace std;

class Animal{
protected: char * pos;
public: void printLivingPosition(){ cout << "I live in the " << pos << endl;}
};

class Bird : public Animal{
public: Bird(){ pos =  "Sky";}
};

class Fish : public Animal{
public: Fish(){ pos =  "Sea";}
};

class AnimalFactory{ // 簡單工廠
public:
 static Animal* createAnimal(string kind){
  if(strcmp("Fish",kind.c_str()) == 0)
   return new Fish();
  else if(strcmp("Bird",kind.c_str()) == 0)
   return new Bird();
  else
   return NULL;
 }
};
int main(){
 Animal *a = AnimalFactory::createAnimal("Fish"); // 使用工廠進行例項化，完成多型
 a->printLivingPosition();
 Animal *b = AnimalFactory::createAnimal("Bird");
 b->printLivingPosition();
 delete(a);
 delete(b);
 return 0;
}
 

例項3

AbstractProduct.h

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_


#include <stdio.h>


class AbstractProduct{

public:
    AbstractProduct();
    virtual ~AbstractProduct();
    
public:
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct{

public:
    ProductA();
    virtual ~ProductA();
    
public:
    void operation();
};

class ProductB:public AbstractProduct{

public:
    ProductB();
    ~ProductB();
    
public:
    void operation();
};

#endif
 

#include "AbstractProduct.h"

AbstractProduct::AbstractProduct(){
}


AbstractProduct::~AbstractProduct(){
}


ProductA::ProductA(){
}


ProductA::~ProductA(){
}


void ProductA::operation(){
    fprintf(stderr,"productA operation!\n");
}


ProductB::ProductB(){
}


ProductB::~ProductB(){
}


void ProductB::operation(){
    fprintf(stderr,"productB operation!\n");
}

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#include "AbstractProduct.h"


class AbstractFactory{

public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProduct* createProduct(int type) = 0;    
};


class SimpleFactory:public AbstractFactory{

public:
    SimpleFactory();
    ~SimpleFactory();
    
public:
    AbstractProduct* createProduct(int type);
};

#endif

#include "SimpleFactory.h"


AbstractFactory::AbstractFactory(){
}


AbstractFactory::~AbstractFactory(){
}


SimpleFactory::SimpleFactory(){
}


SimpleFactory::~SimpleFactory(){
}


AbstractProduct* SimpleFactory::createProduct(int type){
    AbstractProduct* temp = NULL;
    switch(type)
    {
    case 1:
        temp = new ProductA();
        break;
    case 2:
        temp = new ProductB();
        break;
    default:
        break;
    }
    return temp;
}

#include "SimpleFactory.h"


int main(){
    AbstractFactory* factory = new SimpleFactory();
    AbstractProduct* product = factory->createProduct(1);
    product->operation();
    delete product;
    product = NULL;
    
    product = factory->createProduct(2);
    product->operation();
    delete product;
    product = NULL;
    return 0;
}