众所周知：只能生成一个对象的是单例模式，但是看一下情况：
假设定义一个Printer 类：
建立 Printer 对象 p1;
使用 p1;
释放 p1;
建立Printer对象p2;
使用 p2;
释放 p2;
...
这种设计在同一时间里没有实例化多个Printer对象， 而是在程序的不同部分使用了不
同的Printer对象。不允许这样编写有些不合理。毕竟我们没有违反只能存在一个printer
的约束。就没有办法使它合法化么？
当然有：
class Printer {
public:
class TooManyObjects{}; //异常类
// 伪构造函数
static Printer * makePrinter();
~Printer();
void submitJob(const PrintJob& job);
void reset();
void performSelfTest();
...
private:
static size_t numObjects;
Printer();
Printer(const Printer& rhs); //我们不定义这个函数
}; //因为不允许
//进行拷贝
// Obligatory definition of class static
size_t Printer::numObjects = 0;
Printer::Printer()
{
if (numObjects >= 1) {
throw TooManyObjects();
}
继续运行正常的构造函数;
++numObjects;
}
Printer * Printer::makePrinter()
{ return new Printer; }
当需要的对象过多时，会抛出异常，如果你认为这种方式给你的感觉是unreasonably
harsh，你可以让伪构造函数返回一个空指针。当然用户在使用之前应该进行检测。
除了用户必须调用伪构造函数，而不是真正的构造函数之外，它们使用Printer类就象
使用其他类一样：
Printer p1; // 错误! 缺省构造函数是private
Printer *p2 =
Printer::makePrinter(); // 正确, 间接调用缺省构造函数
Printer p3 = *p2; // 错误! 拷贝构造函数是private
p2->performSelfTest(); // 所有其它的函数都可以
p2->reset(); // 正常调用
...
delete p2; // 避免内存泄漏，如果
// p2 是一个 auto_ptr，
// 就不需要这步。
这种技术很容易推广到限制对象为任何数量上。我们只需把hard-wired常量值1改为
根据某个类而确定的数量，然后消除拷贝对象的约束。例如，下面这个经过修改的Printer类的代码实现，最多允许10个Printer对象存在：
class Printer {
public:
class TooManyObjects{};
// 伪构造函数
static Printer * makePrinter();
static Printer * makePrinter(const Printer& rhs);
...
private:
static size_t numObjects;
static const size_t maxObjects = 10; // 见下面解释
Printer();
Printer(const Printer& rhs);
};
// Obligatory definitions of class statics
size_t Printer::numObjects = 0;
const size_t Printer::maxObjects;
Printer::Printer()
{
if (numObjects >= maxObjects) {
throw TooManyObjects();
}
...
}
Printer::Printer(const Printer& rhs)
{
if (numObjects >= maxObjects) {
throw TooManyObjects();
}
...
}
Printer * Printer::makePrinter()
{ return new Printer; }
Printer * Printer::makePrinter(const Printer& rhs)
{ return new Printer(rhs); }
如果你的编译器不能编译上述类中Printer::maxObjects的声明，这丝毫也不奇怪。特
别是应该做好准备， 编译器不能编译把10做为初值赋给这个变量这条语句。 给static const成员（例如int, char, enum等等）确定初值的功能是最近才加入到C++中的，所以一些编译器还不允许这样编写。如果没有及时更新你的编译器，可以把maxObjects声明为在一个private内匿名枚举类型里的枚举元素，
class Printer {
private:
enum { maxObjects = 10 }; // 在类中,
... // maxObjects为常量10
};
或者象non-const static成员一样初始化static常量：
class Printer {
private:
static const size_t maxObjects; // 没有赋给初值
...
};
// 放在一个代码实现的文件中
const size_t Printer::maxObjects = 10;
后面这种方法与原来的方法有一样的效果， 但是显示地确定初值能让其他程序员更容易理解。当你的编译器支持在类定义中给const static成员赋初值的功能时，你应该尽可能地利用这个功能。
一个具有对象计数功能的基类
如果我们有大量像Printer需要限制实例数量的类，就必须一遍又一遍地编写一样的代码，每个类编写一次。这将会使大脑变得麻木。应该有一种方法能够自动处理这些事情。难道没有方法把实例计数的思想封装在一个类里吗？
我们很容易地能够编写一个具有实例计数功能的基类， 然后让像Printer这样的类从该
基类继承，而且我们能做得更好。
template<class BeingCounted>
class Counted {
public:
class TooManyObjects{}; // 用来抛出异常
static int objectCount() { return numObjects; }
protected:
Counted();
Counted(const Counted& rhs);
~Counted() { --numObjects; }
private:
static int numObjects;
static const size_t maxObjects;
void init(); // 避免构造函数的
}; // 代码重复
template<class BeingCounted>
Counted<BeingCounted>::Counted()
{ init(); }
template<class BeingCounted>
Counted<BeingCounted>::Counted(const Counted<BeingCounted>&)
{ init(); }
template<class BeingCounted>
void Counted<BeingCounted>::init()
{
if (numObjects >= maxObjects) throw TooManyObjects();
++numObjects;
}
从这个模板生成的类仅仅能被做为基类使用，因此构造函数和析构函数被声明为
protected。注意private成员函数init用来避免两个Counted构造函数的语句重复。
现在我们能修改Printer类
class Printer: private Counted<Printer> {
public:
// 伪构造函数
static Printer * makePrinter();
static Printer * makePrinter(const Printer& rhs);
~Printer();
void submitJob(const PrintJob& job);
void reset();
void performSelfTest();
...
using Counted<Printer>::objectCount; // 参见下面解释
using Counted<Printer>::TooManyObjects; // 参见下面解释
private:
Printer();
Printer(const Printer& rhs);
};
Printer使用了Counter模板来跟踪存在多少Printer对象，坦率地说，除了Printer
的编写者，没有人关心这个事实。它的实现细节最好是 private，这就是为什么这里使用
private继承的原因。另一种方法是在Printer和counted<Printer>之间使用public继承，但是我们必须给Counted类一个虚拟析构函数。（否则如果有人通过Counted<Printer>*指针删除一个Printer对象，我们就有导致对象行为不正确的风险）。在Counted中存在虚函数，几乎肯定影响从Counted继承下来的对象的大小和布局。我们不想引入这些额外的负担，所以使用private继承来避免这些负担。
Counted所做的大部分工作对于Printer的用户来说都是隐藏的，但是这些用户可能很
想知道有当前多少Printer对象存在。Counted模板提供了objectCount函数，用来提供这
种信息，但是因为我们使用private继承，这个函数在Printer类中成为了private。为了
恢复该函数的public访问权，我们使用using声明：
class Printer: private Counted<Printer> {
public:
...
using Counted<Printer>::objectCount; // 让这个函数对于Printer
//是public
...
};
这样做是合乎语法规则的，但是如果你的编译器不支持命名空间，编译器就不允许这样做。如果这样的话，你应使用老式的访问权声明语法：
class Printer: private Counted<Printer> {
public:
...
Counted<Printer>::objectCount; // 让objectCount
// 在Printer中是public
...
};
这种更传统的语法与uning声明具有相同的含义。但是我们不赞成这样做。
TooManyObjects类应该也应用同样的方式来处理，因为Printer的客户端如果要捕获这种
异常类型，它们必须有能力访问TooManyObjects。当Printer继承Counted<Printer>时，
它可以忘记有关对象计数的事情。编写Printer类时根本不用考虑对象计数，就好像有其他人会为它计数一样。
Printer的构造函数可以是这样的： Printer::Printer()
{
进行正常的构造函数运行
}
这里有趣的不是你所见到的东西，而是你看不到的东西。不检测对象的数量就好像限制
将被超过，执行完构造函数后也不增加存在对象的数目。所有这些现在都是由Counted<Printer>的构造函数来处理，因为Counted<Printer>是Printer的基类，我们知
道Counted<Printer>的构造函数总在 Printer 的前面被调用。如果建立过多的对象，
Counted<Printer>的构造函数就会抛出异常，甚至都没有调用Printer的构造函数。
最后还有一点需要注意，必须定义Counted内的静态成员。对于numObjects来说，这
很容易——我们只需要在Counted的实现文件里定义它即可：
template<class BeingCounted> // 定义numObjects
int Counted<BeingCounted>::numObjects; // 自动把它初始化为0
对于maxObjects来说，则有一些技巧。我们应该把它初始化为什么值呢？如果你想允许建立10个printer对象，我们应该初始化Counted<Printer>::maxObjects为10。另一方面如果我们向允许建立16个文件描述符对象，我们应该初始化Counted<Printer>::maxObjects为16。到底应该怎么做呢？
简单的方法就是什么也不做。我们不对maxObject进行初始化。而是让此类的客户端提供合适的初始化。
Printer的作者必须把这条语句加入到一个实现文件里：
const size_t Counted<Printer>::maxObjects = 10;
同样FileDescriptor的作者也得加入这条语句：
const size_t Counted<FileDescriptor>::maxObjects = 16;
如果这些作者忘了对maxObjects进行初始化，会发生什么情况呢？很简单：连接时会
发生错误，因为maxObjects没有被定义。如果我们提供了充分的文档对Counted客户端说明了需求，他们会回去加上这个必须的初始化。
869
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
