前言
本节内容的极端情况即为禁止建立对象与单例模式。
禁止对象实例化
如果我们需要阻止建立某个类的对象，应该把它的构造函数设为private:1
2
3
4
5
6class CantBeInstantiated {
private:
CantBeInstantiated();
CantBeInstantiated(const CantBeInstantiated&);
...
};
单例模式
假设我们现在只允许生成一个打印机对象，我们应当把这个对象封装置入某个函数，允许所有人访问，但只有一个对象存在：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17class PrintJob;
class Printer {
public:
void submitJob(const PrintJob& job);
void reset();
void performSelfTest();
...
friend Printer& thePrinter();
private:
Printer();
Printer(const Printer& rhs);
...
};
Printer& thePrinter(){
static Printer p; // 单个打印机对象
return p;
}
这个设计有三部分：
- printer无法构造
- 全局函数thePrinter被设为friend，因此可以调用private构造函数。
- thePrinter包含一个静态Printer对象，这意味着只有一个对象被建立。我们只能通过thePrinter函数来使用这个对象。
静态函数
有人会认为thePrinter没必要污染全局命名空间，为此解决方法是把thePrinter声明为printer内部的静态函数，那顺便去除了friend属性：1
2
3
4
5
6
7
8
9
10
11
12
13class Printer{
public:
static Printer& thePrinter();
...
private:
Printer();
Printer(const Printer& rhs);
...
};
Printer& Printer::thePrinter(){
static Printer p;
return p;
}
就是调用函数的时候麻烦了一些：1
2Printer::thePrinter().reset();
Printer::thePrinter().submitJob(buffer);
新建命名空间
另一种做法是将class与thePrinter移出全局域，放入专属namespace，防止命名冲突：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16namespace PrintingStuff{
class Printer{
public:
void submitJob(const PrintJob& job);void reset();
void performSelfTest();
...
friend Printer& thePrinter();
private:
Printer();
Printer(const Printer& rhs);
...
};
Printer& thePrinter(){
static Printer p;
return p;
}
只不过这样一来调用每一次调用都必须提及命名空间：1
2PrintingStuff::thePrinter().reset();
PrintingStuff::thePrinter().submitJob(buffer);
又或者使用using：1
2
3using PrintingStuff::thePrinter;
thePrinter().reset();
thePrinter().submitJob(buffer);
单例模式实现细节
thePrinter的实现有两个微妙之处：
- p是函数中的静态对象而非类中的静态对象
如果是类中的静态对象，则该对象总是会被构造和析构。（即使你根本没有试图去使用）函数中的则不同，只有第一次调用函数时才会被构造。当然，我们也为此付出了代价：每一次都必须检查是否需要建立对象。
如果对象是类中的静态成员，它的初始化时间难以确定，我们清楚的了解函数的静态对象初始化于函数的第一次调用，而类则说不准。 - 关注内联与函数内静态对象的关系
我们看得出thePrinter的函数体非常简短，很适合内联，但我们不能内联它。因为对于非成员函数，内联会导致复制obj中的代码，简单来说，就连静态对象也被复制了。所以不要内联包含局部静态数据的非成员对象。
多例模式(限制数目）
一般来说，限制对象数目的核心思想在于：实时跟踪当前已生成的对象数目，如果超出则抛出异常：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22class Printer {
public:
class TooManyObjects{};//异常类
Printer();
~Printer();
...
private:
static size_t numObjects;
Printer(const Printer& rhs);//禁止拷贝
};
size_t Printer::numObjects = 0;
Printer::Printer(){
if (numObjects >= 1) {
throw TooManyObjects();
}
...//执行构造
++numObjects;
}
Printer::~Printer(){
...//执行析构;
--numObjects;
}
这种方法相当直观，就是设计起来存在些许小小的问题。
建立对象的环境
假设我们有一个彩色打印机，继承自printer：1
2
3class ColorPrinter: public Printer {...};
Printer p;
ColorPrinter cp;
上述定义产生了两个Printer对象,于是，在构造cp的基类部分时抛出了异常（More Effective C++ 33提出设计时避免非尾端类为具象类）。
如果有其他对象包含Printer对象，也会有同样的问题：1
2
3
4
5
6
7
8
9class CPFMachine {
private:
Printer p;//有打印能力
FaxMachine f;//有传真能力
CopyMachine c;//有复印能力
...
};
CPFMachine m1;//运行正常
CPFMachine m2;//抛出异常
这些问题的根源在于Pointer对象可以在3种不同状态下生存：
- 仅有自身
- 作为派生对象的base成分
- 内嵌于较大对象
这直接导致了我们心目中的“目标个数”与编译器看到的目标个数不一致。
private构造函数
通常情况下我们只对状态1感兴趣，那把构造函数设为private可以很有效地满足我们。带有private构造函数的类无法作为基类，也无法内嵌到其他对象中。
private构造函数是一种阻止产生派生类的好手段，具体来说，假如你有一个类FSA（finite state automata），我们允许它产生多个对象，但禁止从它派生出新类：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16class FSA {
public:
static FSA * makeFSA();
static FSA * makeFSA(const FSA& rhs);
...
private:
FSA();
FSA(const FSA& rhs);
...
};
FSA* FSA::makeFSA(){
return new FSA();
}
FSA* FSA::makeFSA(const FSA& rhs){
return new FSA(rhs);
}
不同于thePrinter函数总是返回一个对象的引用（引用的对象是固定的），每个 makeFSA的伪构造函数则是返回一个指向对象的指针，也就是说允许建立的 FSA 对象数量没有限制。
为了防止资源泄漏，最佳方案自然是RAII：1
2auto_ptr<FSA> pfsa1(FSA::makeFSA());
auto_ptr<FSA> pfsa2(FSA::makeFSA(*pfsa1));
允许对象自由生灭
在之前的设计手法中，首次我们调用thePrinter时，对象被构造，但我们无法控制对象的销毁，也就是说无法达成这样的功能：1
2
3
4
5
6建立Printer对象 p1;
使用p1;
释放p1;
建立Printer对象 p2;
使用p2;
释放p2;
解决方法就是把对象计数和伪构造函数合并：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26class 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);
};
size_t Printer::numObjects = 0;
Printer::Printer(){
if (numObjects >= 1) {
throw TooManyObjects();
}
...//执行构造
++numObjects;
}
Printer::~Printer(){
...//执行析构;
--numObjects;
}
除了用户必须调用伪构造函数之外，这一切使用起来就如同其他类：1
2
3
4
5
6
7Printer p1;//error 构造函数为private
Printer *p2 =Printer::makePrinter();
Printer p3 = *p2; //error 禁止拷贝
p2->performSelfTest();
p2->reset();
...
delete p2;//避免资源泄漏
如果我们需要制定最多生成N个，那只要在class中定义一个static const maxsize=N就ok：1
2
3
4
5
6
7
8
9
10
11
12
13
14class Printer {
public:
class TooManyObjects{};
static Printer * makePrinter();
static Printer * makePrinter(const Printer& rhs);
...
private:
static size_t numObjects;//声明
static const size_t maxObjects = 10;//内置static类型可以直接在class中声明时定义
Printer();
Printer(const Printer& rhs);
};
size_t Printer::numObjects = 0;//在类外定义
const size_t Printer::maxObjects;//定义
建立具有计数功能的基类
如果我们需要大量这种限制产出对象数量的class，难道我们要一遍一遍地重复编写？当然不是。
理想做法是编写一个具有实例计数功能的基类，然后让产出受限的类继承该类。我们使用一种方法封装计数功能，这种做法不但封装维护实例计数器的函数，也封装实例计数器本身。
下面给出该类的具体实现：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27template<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;
}
于是最终的Printer类如下所示：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15class 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);
};
用户有权得知当前的对象数目以及最大数目，private继承使得它们被隐藏，因此需要在public中使用using来获取他们。
最后需要注意的就是定义counted内部的静态成员，对于numobject，我们只需要在counted的实现中定义：1
2template<class BeingCounted>
int Counted<BeingCounted>::numObjects;//自动初始化为0
max的定义则略微麻烦，我们不初始化它，而是留待客户进行初始化。以Printer举例：1
const size_t Counted<Printer>::maxObjects = 10;
如果客户没写，那么在连接时会报错。
