设计模式（四）多例模式

　　多例模式是相对单例模式而言的。单例模式有且仅有一个实例，但是多例模式，顾问思义：允许存在有限个实例。 什么叫“有限个实例”？ 就是说：有多少实例，我们是知道的，并不是不可以预知的， 如果一个类的构造函数是public 的，那么在任意地方都可以通过调用构造函数来创建实例，那么这样的实例是我们不能预知的。这是有上限多例模式，但是多例模式还有一种无上限多例模式。因此，多例模式有以下特点：

　　（1）允许有多个实例。

　　（2）多例类自己负责创建、管理自己的实例、并向外接提供自己的实例。因此，它的构造函数也是private的，这点跟单例模式是相同的。

　　

　　

　　举个例子：

　　还是用皇帝和大臣的例子吧。假设同一时期有多个皇帝。0.0　

　　代码如下：

/*
Time:2016-9-26 21:06:18
Author:CodingMengmeng
Description:
多例模式：单例模式的扩展
思路：
指定实例的个数->用一个容器来存储实例->定义一个索引，用于查找指定的实例
当然，和单例模式一样，也需要将构造函数私有化
同时，实例个数，索引，容器等变量都是每个实例共有的，所以应声明为静态。
*/
/*
还是用之前单例模式中提到的皇帝的例子，假设有几个皇帝吧0.0
*/
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <time.h>
using namespace std;

class CEmperor{
private:
    //构造函数私有化
    CEmperor(string name);
    ~CEmperor();
    //定义最多能产生的实例数量
    static int maxNumOfEmperor;
    //每个Emperor都有name，使用一个vector来容纳，且声明为静态的
    static vector<string> nameList;
    //定义一个vector，容纳所有Emperor实例
    static vector<CEmperor*> emperorList;
    //当前emperor序列号
    static int indexOfEmperor;
public:
    //产生所有实例
    static void ProduceAllInstances();
    //获取实例
    static CEmperor* GetInstance();
    //实例的行为
    static void EmperorSay();
};

//所有静态变量使用前必须在类外初始化
int CEmperor::indexOfEmperor = 0;
int CEmperor::maxNumOfEmperor = 3;
vector<string> CEmperor::nameList(0);
vector<CEmperor*> CEmperor::emperorList(0);
//构造函数中，将name传入
CEmperor::CEmperor(string name)
{
    nameList.push_back(name);
}

//析构函数，释放当前序号对应的实例
CEmperor::~CEmperor()
{
    delete emperorList[indexOfEmperor];
}


void CEmperor::ProduceAllInstances()
{
    for (int i = 0; i < maxNumOfEmperor; i++)
    {
        stringstream ss;//为了将int转为string而定义。。
        ss << i+1;
        string str;
        string str1 = "Emperor";
        string str2;
        ss >> str2;
        str = str1 + str2;
        emperorList.push_back(new CEmperor(str));//传入name，生成maxNumOfEmperor个实例
    }
}

CEmperor* CEmperor::GetInstance()
{
    //随机获得一个CEmperor实例
    indexOfEmperor = rand() % maxNumOfEmperor;//对maxNumOfEmperor求余，则indexOfEmperor的范围在[0,maxNumOfEmperor)中
    return emperorList[indexOfEmperor];

}

void CEmperor::EmperorSay()
{
    string nameString = "";
    nameString = nameList[indexOfEmperor];
    cout << nameString << endl;
}

int main(void)
{
    //首先产生实例
    CEmperor::ProduceAllInstances();
    //假设有五位minister来参拜
    int ministerNum = 5;
    srand(time(0));//以当前时间为随机数种子~~！
    for (int i = 0; i < ministerNum; i++)
    {
        CEmperor* emperor = CEmperor::GetInstance();
        cout << "第" << i + 1 << "个Minister参拜的是：";
        emperor->EmperorSay();
    }
    return 0;
}

　　运行结果：

　　

　　

　　看，果然每个大臣参拜的皇帝都肯可能不一样。

　　这种需要产生固定数量对象的模式就叫做有上限的多例模式，它是单例模式的一种扩展，采用有上限的多例模式，我们可以在设计时决定在内存中有多少个实例，方便系统进行扩展，修正单例可能存在的性能问题，提高系统的响应速度。