抽象工厂模式鲁菜红烧肉.doc

#include <iostream> 
#include <string> 
using namespace std; 
//
红烧肉

class CHongshaorou 
{ 
public: 
    virtual ~CHongshaorou() {}; 
    //
产品使用公共接口

    virtual void Start() = 0;//
抽象基类，纯虚函数由派生类去实现

}; 
 //
鲁菜红烧肉
 class CHongshaorouLucai : public CHongshaorou 
{ 

public: 
    CHongshaorouLucai() 
    { 
        cout << "
制作鲁菜红烧肉
." << endl; 
    } 
    virtual ~CHongshaorouLucai() {}; 
    virtual void Start() 
    { 
        cout << "
鲁菜红烧肉好了
." << endl; 
    }; 
}; 
//
粤菜红烧肉

class CHongshaorouYuecai : public CHongshaorou 
{ 
public: 
    CHongshaorouYuecai() 
    { 
        cout << "
制作粤菜红烧肉
." << endl; 
    } 
    virtual ~CHongshaorouYuecai() {}; 
    virtual void Start() 
    { 
        cout << "
粤菜红烧肉好了
." << endl; 
    }; 
}; 
 //
清蒸鱼

class Cqingzhengyu 
{ 
public: 
    virtual ~Cqingzhengyu() {}; 
    //
产品使用公共接口

    virtual void Start() = 0;//
抽象基类，纯虚函数由派生类去实现

}; 
 //
鲁菜清蒸鱼

class CqingzhengyuLucai : public Cqingzhengyu 
{ 
public: 
    CqingzhengyuLucai() 
    { 
        cout << "
制作鲁菜清蒸鱼
." << endl; 
    } 
    virtual ~CqingzhengyuLucai() {}; 
    virtual void Start() 
    { 
        cout << "
鲁菜清蒸鱼好了
." << endl; 
    }; 
}; 
 //
粤菜清蒸鱼

class CqingzhengyuYuecai : public Cqingzhengyu 
{ 
public: 
    CqingzhengyuYuecai() 
    { 
        cout << "
制作粤菜清蒸鱼
." << endl; 
    } 
    virtual ~CqingzhengyuYuecai() {}; 
    virtual void Start() 
    { 
        cout << "
粤菜清蒸鱼好了
." << endl; 
    }; 
}; 
//
抽象工厂

class CFactory 
{ 
public: 
    virtual ~CFactory(){}; 
    virtual CHongshaorou* CreateHongshaorou() = 0; 
    virtual Cqingzhengyu* Createqingzhengyu() = 0; 
}; 
//
鲁菜工厂

class CLucaiFactory : public CFactory 
{ 
public: 
    CLucaiFactory() 
    { 
        cout << "
制作鲁菜工厂
." << endl; 
    } 
    virtual ~CLucaiFactory(){}; 
    virtual CHongshaorou* CreateHongshaorou() 
    { 
        return new CHongshaorouLucai; 
    }; 
    virtual Cqingzhengyu* Createqingzhengyu() 
    { 
        return new CqingzhengyuLucai; 
     }; 
}; 
//
粤菜工厂

class CYuecaiFactory : public CFactory 
{ 
public: 
    CYuecaiFactory() 
    { 
        cout << "
制作粤菜工厂
." << endl; 
    } 
    virtual ~CYuecaiFactory(){}; 
    virtual CHongshaorou* CreateHongshaorou() 
    { 
        return new CHongshaorouYuecai; 
    }; 
    virtual Cqingzhengyu* Createqingzhengyu() 
    { 
        return new CqingzhengyuYuecai; 
    }; 
}; 
void Test(CFactory* pFactory) 
{ 
    CHongshaorou* pHongshaorou = NULL; 
    Cqingzhengyu* pqingzhengyu = NULL; 
    pHongshaorou = pFactory->CreateHongshaorou();//
制作红烧肉

    pqingzhengyu = pFactory->Createqingzhengyu();//
制作清蒸鱼

    pHongshaorou->Start(); 
    pqingzhengyu->Start(); 
    delete pqingzhengyu; 
    delete pHongshaorou; 
}; 
int main() 
{ 
    CFactory* pFactory = NULL;//
抽象工厂

    //
鲁菜工厂。做红烧肉，清蒸鱼

    pFactory = new CLucaiFactory;//
制作鲁菜工厂

    Test(pFactory); 
    delete pFactory; 
    cout<<endl; 
    //
粤菜工厂。做红烧肉，清蒸鱼

    pFactory= new CYuecaiFactory;//
制作粤菜工厂

    Test(pFactory); 
    delete pFactory; 
    system("pause"); 
    return 0; 
}