abstractfactory.c++

这是一个关于设计模式的源码

#include <iostream>

using namespace std;
//---------------------------------------------------------------------------
class AbstractProductA
{
public :
    virtual void show() = 0;
};

class ProductA1 : public AbstractProductA
{
public :
    void show();
};

void ProductA1::show()
{
    cout << "ProductA1" << endl;
}

class ProductA2 : public AbstractProductA
{
public :
    void show();
};

void ProductA2::show()
{
    cout << "ProductA2" << endl;
}
//---------------------------------------------------------------------------
class AbstractProductB
{
public :
    virtual void Interact(AbstractProductA *a) = 0;
};

class ProductB1 : public AbstractProductB
{
public :
    void Interact(AbstractProductA *a);
};

void ProductB1::Interact(AbstractProductA *a)
{
    cout << "This is ProductB1's Interact fun." << endl;
    a->show();
}

class ProductB2 : public AbstractProductB
{
public :
    void Interact(AbstractProductA *a);
};

void ProductB2::Interact(AbstractProductA *a)
{
    cout << "This is ProductB2's Interact fun." << endl;
    a->show();
}
//---------------------------------------------------------------------------
class AbstractFactory
{
public :
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

class ConcreteFactory1 : public AbstractFactory
{
public :
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};

AbstractProductA* ConcreteFactory1::createProductA()
{
   return new ProductA1();
}

AbstractProductB* ConcreteFactory1::createProductB()
{
    return new ProductB1();
}

class ConcreteFactory2 : public AbstractFactory
{
public :
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};

AbstractProductA* ConcreteFactory2::createProductA()
{
   return new ProductA2();
}

AbstractProductB* ConcreteFactory2::createProductB()
{
    return new ProductB2();
}
//---------------------------------------------------------------------------
class Client
{
public :
    Client(AbstractFactory *factory);
    void run();
private:
    AbstractProductA *abstractProductA;
    AbstractProductB *abstractProductB;
};

Client::Client(AbstractFactory *factory)
{
    abstractProductA = factory->createProductA();
    abstractProductB = factory->createProductB();
}

void Client::run()
{
    abstractProductB->Interact(abstractProductA);
}
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
    AbstractFactory *factory1 = new ConcreteFactory1();
    Client client1(factory1);
    client1.run();

    AbstractFactory *factory2 = new ConcreteFactory2();
    Client client2(factory2);
    client2.run();

    delete factory1;
    delete factory2;

    getchar();

    return 0;
}