游戲中的設計模式：工廠模式

 

現在的網游更新很快，要延長網絡游戲生命周期的方法是，更新，不斷地更新，不斷的將新內容呈現於玩家面前。這要求游戲程序的設計要有彈性，代碼的重用至關重要。

今天就說說游戲中的工廠模式。

說到工廠模式，有簡單工廠模式，工廠方法模式，抽象工廠模式。

 

（一）簡單工廠模式

ps：面向對象的編程，並不是類越多越好，類的划分是為了封裝，但分類的基礎是抽象，具有相同屬性和功能的對象的抽象集合才是類。

主要用於創建對象。新添加類時，不會影響以前的系統代碼。核心思想是用一個工廠來根據輸入的條件產生不同的類，然后根據不同類的virtual函數得到不同的結果。

​

（工廠類與基類為關聯關系）

//基類
class COperation
{
public:
    int m_nFirst;
    int m_nSecond;
    virtual double GetResult()
    {
        double dResult=0;
        return dResult;
    }
};

//加法
class AddOperation : public COperation
{
public:
    virtual double GetResult()
    {
        return m_nFirst+m_nSecond;
    }
};

//減法
class SubOperation : public COperation
{
public:
    virtual double GetResult()
    {
        return m_nFirst-m_nSecond;
    }
};

//工廠類
class CCalculatorFactory
{
public:
    static COperation* Create(char cOperator);
};

COperation* CCalculatorFactory::Create(char cOperator)
{
    COperation *oper;
    //在C#中可以用反射來取消判斷時用的switch，在C++中用什么呢？RTTI？？
    switch (cOperator)
    {
    case '+':
        oper=new AddOperation();
        break;
    case '-':
        oper=new SubOperation();
        break;
    default:
        oper=new AddOperation();
        break;
    }
    return oper;
}

客戶端

int main()
{
    int a,b;
    cin>>a>>b;
    COperation * op=CCalculatorFactory::Create('-');
    op->m_nFirst=a;
    op->m_nSecond=b;
    cout<<op->GetResult()<<endl;
    return 0;
}

優：適用於不同情況創建不同的類時。

劣：客戶端必須要知道基類和工廠類，耦合性差。

 

（二）工廠方法模式

簡單工廠模式的最大優點在於工廠類中包含了必要的邏輯判斷，根據客戶端的選擇條件動態實例化相關的類，對於客戶端來說，去除了與具體產品的依賴。但簡單工廠模式中不遵守開放－封閉原則。代碼耦合性差。

​

 

#include <string>
#include <iostream>
using namespace std;
//實例基類，相當於Product(為了方便，沒用抽象)
class LeiFeng
{
public:
    virtual void Sweep()
    {
        cout<<"雷鋒掃地"<<endl;
    }
};

//學雷鋒的大學生，相當於ConcreteProduct
class Student: public LeiFeng
{
public:
    virtual void Sweep()
    {
        cout<<"大學生掃地"<<endl;
    }
};

//學雷鋒的志願者，相當於ConcreteProduct
class Volenter: public LeiFeng
{
public :
    virtual void Sweep()
    {
        cout<<"志願者"<<endl;
    }
};
//工場基類Creator
class LeiFengFactory
{
public:
    virtual LeiFeng* CreateLeiFeng()
    {
        return new LeiFeng();
    }
};
//工場具體類
class StudentFactory : public LeiFengFactory
{
public :
    virtual LeiFeng* CreateLeiFeng()
    {
        return new Student();
    }
};
class VolenterFactory : public LeiFengFactory
{
public:
    virtual LeiFeng* CreateLeiFeng()
    {
        return new Volenter();
    }
};

 //客戶端

int main()
{
    LeiFengFactory *sf=new LeiFengFactory();
    LeiFeng *s=sf->CreateLeiFeng();
    s->Sweep();
    delete s;
    delete sf;
    return 0;
}

優：修正了簡單工廠模式中不遵守開放－封閉原則。工廠方法模式把選擇判斷移到了客戶端去實現，如果想添加新功能就不用修改原來的類，直接修改客戶端即可。

 

（三）抽象工廠模式

提供一個創建一系列相關或相互依賴的接口，而無需指定它們的具體類。

​

 

#include <string>
#include <iostream>
#include <vector>
using namespace std;

//用戶抽象接口
class IUser
{
public :
    virtual void GetUser()=0;
    virtual void InsertUser()=0;
};

//部門抽象接口
class IDepartment
{
public:
    virtual void GetDepartment()=0;
    virtual void InsertDepartment()=0;
};

//ACCESS用戶
class CAccessUser : public IUser
{
public:
    virtual void GetUser()
    {
        cout<<"Access GetUser"<<endl;
    }
    virtual void InsertUser()
    {
        cout<<"Access InsertUser"<<endl;
    }
};

//ACCESS部門
class CAccessDepartment : public IDepartment
{
public:
    virtual void GetDepartment()
    {
        cout<<"Access GetDepartment"<<endl;
    }
    virtual void InsertDepartment()
    {
        cout<<"Access InsertDepartment"<<endl;
    }
};

//SQL用戶
class CSqlUser : public IUser
{
public:
    virtual void GetUser()
    {
        cout<<"Sql User"<<endl;
    }
    virtual void InsertUser()
    {
        cout<<"Sql User"<<endl;
    }
};

//SQL部門類
class CSqlDepartment: public IDepartment
{
public:
    virtual void GetDepartment()
    {
        cout<<"sql getDepartment"<<endl;
    }
    virtual void InsertDepartment()
    {
        cout<<"sql insertdepartment"<<endl;
    }
};

//抽象工廠
class IFactory
{
public:
    virtual IUser* CreateUser()=0;
    virtual IDepartment* CreateDepartment()=0;
};

//ACCESS工廠
class AccessFactory : public IFactory
{
public:
    virtual IUser* CreateUser()
    {
        return new  CAccessUser();
    }
    virtual IDepartment* CreateDepartment()
    {
        return new CAccessDepartment();
    }
};

//SQL工廠
class SqlFactory : public IFactory
{
public:
    virtual IUser* CreateUser()
    {
        return new  CSqlUser();
    }

    virtual IDepartment* CreateDepartment()
    {
        return new CSqlDepartment();
    }
};

 客戶端：

int main()
{
    IFactory* factory= new SqlFactory();
    IUser* user=factory->CreateUser();
    IDepartment* depart = factory->CreateDepartment();
    user->GetUser();
    depart->GetDepartment();
    return 0;
}

 

 參考：

游戲中的設計模式：工廠模式