[创建型模式] AbstractFactory

AbstractFactory.h

//
//  AbstractFactory.h
//  AbstractFactory
//
//  Created by Cheney Shen on 11-2-20.
//  Copyright 2011年 __MyCompanyName__. All rights reserved.
//

#ifndef _ABSTARCTFACTORY_H_
#define _ABSTRACTFACOTRY_H_

class AbstractProductA;
class AbstractProductB;

class AbstractFactory
{
    public:
    virtual ~AbstractFactory();
    virtual AbstractProductA* CreateProductA()=0;
    virtual AbstractProductB* CreateProductB()=0;

    protected:
    AbstractFactory();
    
    private:
    
};

class ConcreteFactory1: public AbstractFactory
{
    public:
    ConcreteFactory1();
    ~ConcreteFactory1();
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
    
    protected:
    
    private:
    
};

class ConcreteFactory2: public AbstractFactory
{
    public:
    ConcreteFactory2();
    ~ConcreteFactory2();
    AbstractProductA* CreateProductA();
    AbstractProductB* CreateProductB();
    
    protected:
    
    private:
    
};

#endif  //~_ABSTRACTFACTORY_H_

AbstractFactory.cpp

//
//  AbstractFactory.cpp
//  AbstractFactory
//
//  Created by Cheney Shen on 11-2-20.
//  Copyright 2011年 __MyCompanyName__. All rights reserved.
//

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

AbstractFactory::AbstractFactory()
{
    
}

AbstractFactory::~AbstractFactory()
{
    
}

ConcreteFactory1::ConcreteFactory1()
{
    
}

ConcreteFactory1::~ConcreteFactory1()
{
    
}

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

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

ConcreteFactory2::ConcreteFactory2()
{
    
}

ConcreteFactory2::~ConcreteFactory2()
{
    
}

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

AbstractProductB* ConcreteFactory2::CreateProductB()
{
    return new ProductB2();
}

Product.h

//
//  Product.h
//  AbstractFactory
//
//  Created by Cheney Shen on 11-2-20.
//  Copyright 2011年 __MyCompanyName__. All rights reserved.
//

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class AbstractProductA
{
    public:
    virtual ~AbstractProductA();
    
    protected:
    AbstractProductA();
    
    private:
    
};

class AbstractProductB
{
    public:
    virtual ~AbstractProductB();
    
    protected:
    AbstractProductB();
    
    private:
    
};

class ProductA1: public AbstractProductA
{
    public:
    ProductA1();
    ~ProductA1();
    
    protected:
    
    private:
};

class ProductA2: public AbstractProductA
{
    public:
    ProductA2();
    ~ProductA2();
    
    protected:
    
    private:
    
};

class ProductB1: public AbstractProductB
{
    public:
    ProductB1();
    ~ProductB1();
    
    protected:
    
    private:
    
};

class ProductB2: public AbstractProductB
{
    public:
    ProductB2();
    ~ProductB2();
    
    protected:
    
    private:
    
};

#endif  //~_PRODUCT_H_

Product.cpp

//
//  Product.cpp
//  AbstractFactory
//
//  Created by Cheney Shen on 11-2-20.
//  Copyright 2011年 __MyCompanyName__. All rights reserved.
//

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

AbstractProductA::AbstractProductA()
{
    
}

AbstractProductA::~AbstractProductA()
{
    
}

AbstractProductB::AbstractProductB()
{
    
}

AbstractProductB::~AbstractProductB()
{
    
}

ProductA1::ProductA1()
{
    cout<<"ProductA1..."<<endl;
}

ProductA1::~ProductA1()
{
    
}

ProductA2::ProductA2()
{
    cout<<"ProductA2..."<<endl;
}

ProductA2::~ProductA2()
{
    
}

ProductB1::ProductB1()
{
    cout<<"ProductB1..."<<endl;
}

ProductB1::~ProductB1()
{
    
}

ProductB2::ProductB2()
{
    cout<<"ProductB2..."<<endl;
}

ProductB2::~ProductB2()
{
    
}

main.cpp

//
//  main.cpp
//  AbstractFactory
//
//  Created by Cheney Shen on 11-2-20.
//  Copyright 2011年 __MyCompanyName__. All rights reserved.
//

#include "AbstractFactory.h"

#include <iostream>
using namespace std;

int main (int argc, const char * argv[]) {

    AbstractFactory* cf1 = new ConcreteFactory1();
    
    cf1->CreateProductA();
    cf1->CreateProductB();
    
    AbstractFactory* cf2 = new ConcreteFactory2();
    
    cf2->CreateProductA();
    cf2->CreateProductB();
    
    return 0;
}