class CantBeInstantiated {
private:
  CantBeInstantiated();
  CantBeInstantiated(const CantBeInstantiated&); 
... 
};

class PrintJob;                           // forward 声明
                                          // 参见Effective C++条款34 
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;
}

class PrintJob {
public:
  PrintJob(const string& whatToPrint);
  ... 
}; 
string buffer; 
...                                          //填充buffer 
thePrinter().reset();
thePrinter().submitJob(buffer);

class Printer {
public:
  static Printer& thePrinter();
  ...
private:
  Printer();
  Printer(const Printer& rhs);
  ... 
};
Printer& Printer::thePrinter()
{
  static Printer p;
  return p;
}

Printer::thePrinter().reset();
Printer::thePrinter().submitJob(buffer);

namespace PrintingStuff {
  class Printer {                          // 在命名空间 
  public:                                 // PrintingStuff中的类
    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;
 }
} 
                                        // 命名空间到此结束

PrintingStuff::thePrinter().reset();
PrintingStuff::thePrinter().submitJob(buffer);

using PrintingStuff::thePrinter;    // 从命名空间"PrintingStuff"
                                    //引入名字"thePrinter" 
                                     // 使其成为当前域
thePrinter().reset();               // 现在可以象使用局部命名
thePrinter().submitJob(buffer);    // 一样，使用thePrinter 

Printer& thePrinter()
{
  static Printer p;
  return p;
}

class Printer {
public:
  class TooManyObjects{};                   // 当需要的对象过多时
                                            // 就使用这个异常类  
  Printer();
  ~Printer(); 
  ... 
private:
  static size_t numObjects; 
  Printer(const Printer& rhs);           // 这里只能有一个printer，
                                         // 所以不允许拷贝
};                                  // （参见Effective C++ 条款27） 

TooManyObjects类型的异常：
// Obligatory definition of the class static
size_t Printer::numObjects = 0; 
Printer::Printer()
{
  if (numObjects >= 1) {
    throw TooManyObjects();
  } 
  继续运行正常的构造函数; 
  ++numObjects;
} 
Printer::~Printer()
{
  进行正常的析构函数处理; 
  --numObjects;
}

 建立对象的环境

class ColorPrinter: public Printer {
  ...
 
};

Printer p;
ColorPrinter cp;

class CPFMachine {                           // 一种机器，可以复印，打印
private:                                     // 发传真。
 
  Printer p;                                 // 有打印能力
  FaxMachine f;                              // 有传真能力
  CopyMachine c;                             // 有复印能力
 
  ...
 
};
 
CPFMachine m1;                        // 运行正常
 
CPFMachine m2;                         // 抛出 TooManyObjects异常

class 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); } 

// 间接调用缺省FSA构造函数
auto_ptr<FSA> pfsa1(FSA::makeFSA()); 
// indirectly call FSA copy constructor
auto_ptr<FSA> pfsa2(FSA::makeFSA(*pfsa1)); 
...                         // 象通常的指针一样使用pfsa1和pfsa2,
                           //不过不用操心删除它们。

 允许对象来去自由

建立 Printer 对象 p1; 
使用 p1; 
释放 p1; 
建立Printer对象p2; 
使用 p2; 
释放 p2; 
...

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);        //我们不定义这个函数
};                                    //因为不允许
                                       //进行拷贝
                                     // (参见Effective C++条款27) 
// Obligatory definition of class static
size_t Printer::numObjects = 0; 
Printer::Printer()
{
  if (numObjects >= 1) {
    throw TooManyObjects();
  } 

  ++numObjects;
} 
Printer * Printer::makePrinter()
{ return new Printer; }

Printer p1;                               // 错误! 缺省构造函数是private
Printer *p2 =
<span style="white-space:pre">	</span>Printer::makePrinter();                   // 正确, 间接调用缺省构造函数
Printer p3 = *p2;                          // 错误! 拷贝构造函数是private
p2->performSelfTest();                   // 所有其它的函数都可以
p2->reset();                             // 正常调用 
... 
delete p2;                                // 避免内存泄漏，如果
                                          // p2 是一个 auto_ptr，
                                          // 就不需要这步。

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); }

class Printer {
private:
  enum { maxObjects = 10 };                // 在类中,
  ...                                      // maxObjects为常量10 
};  

class Printer {
private:
  static const size_t maxObjects;            // 没有赋给初值 
  ... 
}; 
// 放在一个代码实现的文件中
const size_t Printer::maxObjects = 10;

 一个具有对象计数功能的基类

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;
}

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);
};

class Printer: private Counted<Printer> {
public:
  ...
  using Counted<Printer>::objectCount; // 让这个函数对于Printer
                                       //是public
  ...    
};

class Printer: private Counted<Printer> {
public:
  ...
  Counted<Printer>::objectCount;       // 让objectCount
                                       // 在Printer中是public
  ... 
};

Printer::Printer()
{
  进行正常的构造函数运行
}

template<class BeingCounted>                 // 定义numObjects
int Counted<BeingCounted>::numObjects;       // 自动把它初始化为0

const size_t Counted<Printer>::maxObjects = 10;

const size_t Counted<FileDescriptor>::maxObjects = 16;