实例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
AbstractProduct.cpp
#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");
}
SimpleFactory.h
#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
SimpleFactory.cpp
#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;
}
client.cpp
#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;
}