[创建型模式] 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;

}