我的C++实践(14)：限制类对象的个数

    1、允许一个或零个对象： 把所有的构造函数声明为私有，则不能创建任何对象。如果允许只创建一个对象，可用一个全局函数（或静态成员函数）来创建唯一的一个静态对象，并返回其引用，为提高效率，可把全局函数声明为inline。注意这个全局函数要声明为类的友元函数，因为要使用私有的构造函数。
    例如我们想创建一个打印机对象，但希望实际上只有一个打印机，可以这样写：

//printer.hpp：只允许创建一个打印机对象，即单例模式 #ifndef PRINTER_HPP #define PRINTER_HPP class PrintJob{ public: PrintJob(const string& whatToPrint){ //... } //... }; class Printer{ //打印机类 private: //所有构造函数都声明为私有，则不能作为基类使用 Printer(){ //... } Printer(Printer const& rhs){ //... } friend Printer& thePrinter(); //... public: void submitJob(PrintJob const& job){ //... } void reset(){ //... } void performSelfTest(){ //... } //... }; inline Printer& thePrinter(){ //获取唯一的一个打印机对象 static Printer p; return p; } //... #endif

 

    这里我们把thePrinter()实现为一个全局函数，里面只创建一个静态对象，返回其引用，这样客户端代码中的所有thePrinter()调用都只使用这个唯一的静态对象。注意，对构造函数，可以只声明为私有，如果不使用它，则可以不提供定义，但对需要被使用的构造函数（因为是私有，只能在类的成员函数或友元函数中使用）则必须提供定义。当然，我们也可以把thePrinter()实现为Printer类的静态成员函数，这样就不需要友元声明了。但使用全局函数也有优势，因为在某些类中声明的静态对象即使没用到也会被构造（以及析构）出来，而全局函数里的静态对象只有执行函数时才被创建。
    另一方面，我们有时候会把那个唯一的p对象声明为全局的静态对象或Printer类的静态成员，然后在thePrinter()或Printer::thePrinter()中直接返回它，这不是一种好的实现方案。我们称函数内的static对象称为local static对象，其他的static对象（class作用域、namespace作用域、global作用域、file作用域）称为non-local static对象。C++只保证在一个特定编译单元内的静态对象的初始化顺序，对不同编译单元内的non-local static对象的初始化次序没有明确定义。可见这样的实现方案会使得p对象的初始顺序不明确。
    当我们需要用到non-local static对象，又要保证正确的初始化顺序时，解决方法恰恰就是将non-local static对象放在一个inline包装函数中，函数返回一个引用指向此对象（变成local static对象）。用函数调用来替换直接访问non-local static对象，这时函数内的局部静态对象就会有确定的初始化顺序（在第一次执行函数时初始化）。注意，我们通常在设计时并不建议返回指向函数内局部对象的reference，但这里的包装函数行为单纯，只是包装一个static对象并返回其reference，并不做其他工作。当多次调用包装函数时，reference指向同一个static对象，并且值均相同（包装函数内并没有改变对象的成员值），因此这样实现没有副作用。
    注意，构造函数声明为私有的类不能作为基类使用，也不能组合到其他类中来使用。我们可以放宽一点，把构造函数声明为protected的，这样类同样不可以创建对象，但可以被继承。
    2、允许创建任意数量的对象，但不允许作为基类： 把构造函数声明为私有，这样就不允许作为基类了。同时我们提供相应的伪构造函数，用它来创建对象并返回。例如对有限状态机类，如下：

//fsa.hpp：有限状态机类，允许创建任意数量的对象，但不允许作为基类 #ifndef FSA_HPP #define FSA_HPP class FSA{ //有限状态机类 private: //构造函数声明为私有 FSA(){ //... } FSA(FSA const& rhs){ //... } public: static FSA* makeFSA(){ //伪构造函数 return new FSA(); } static FSA* makeFSA(FSA const& rhs){ //伪拷贝构造函数 return new FSA(rhs); } //... }; #endif

    客户端使用这个类时，就必须调用伪构造函数来创建对象。当然，由于对象是动态分配的，这时客户必须自己调用delete来删除对象。
    3、允许对象个数限制在某个给定的值： 使用前面在“模板与继承相结合的威力”中介绍的奇异递归模板模式技术，编写一个具有实例计数功能的基类即可，让需要计数的类继承这个类。因为类要实现计数功能，是一种“实现”的关系，故最好用私有继承，表示用这个基类来实现需要的功能。这里我们做一下修改，当需要计数的类对象个数超过上限时就抛出异常。注意不同的类可以通过特化这个基类的表示上限值的成员，以满足不同类对象个数的要求。

//objectcounter.hpp：对对象创建进行记数的模板 #ifndef OBJECT_COUNTER_HPP #define OBJECT_COUNTER_HPP #include <cstddef> template<typename T> class ObjectCounter{ //用来记录T型对象构造的总个数 private: static std::size_t numObjects;//存在对象的个数 static const std::size_t maxObjects; //对象个数的上限，由需要计数的类来指定 void incr(){ if(ObjectCounter<T>::numObjects>=ObjectCounter<T>::maxObjects) throw TooManyObjects(); ++ObjectCounter<T>::numObjects; } protected: ObjectCounter(){ //缺省构造函数 incr(); } ObjectCounter(ObjectCounter<T> const& rhs){ //拷贝构造函数 incr(); } ~ObjectCounter(){ //析构函数 --ObjectCounter<T>::numObjects; } public: class TooManyObjects{ }; //异常类 static std::size_t objectCount(){ //返回当前对象个数 return ObjectCounter<T>::numObjects; } }; //static成员变量必须在类外进行定义，由于是非const的，因此也要类外初始化 template<typename T> std::size_t ObjectCounter<T>::numObjects=0; #endif

 

//mystring.hpp：使用了对象计数的MyString类 #ifndef MYSTRING_HPP #define MYSTRING_HPP #include "objectcounter.hpp" class MyString : private ObjectCounter<MyString>{ public: //由于是私有继承，要用using把objectCount函数变成公有 using ObjectCounter<MyString>::objectCount; //... }; //特化ObjectCounter的maxObjects成员，值为3，以限制MyString类对象的个数， //这个语句必须加入到MyString类的实现文件中 template<> const std::size_t ObjectCounter<MyString>::maxObjects=3; #endif

//countprinter.hpp：使用了对象计数的Printer类 #ifndef PRINTER_HPP #define PRINTER_HPP #include "objectcounter.hpp" class Printer : private ObjectCounter<Printer>{ public: //由于是私有继承，要用using把objectCount函数变成公有 using ObjectCounter<Printer>::objectCount; //... }; //对Printer，对象个数特化为值4 template<> const std::size_t ObjectCounter<Printer>::maxObjects=4; #endif

//countertest.cpp：客户端代码，对对象计数进行测试 #include <iostream> #include "mystring.hpp" #include "countprinter.hpp" int main(){ MyString s1,s2; std::cout<<"number of MyString: " <<MyString::objectCount()<<std::endl; std::cout<<"number of MyString: " <<s1.objectCount()<<std::endl; s1.~MyString(); //减少一个对象 std::cout<<"number of MyString: " <<MyString::objectCount()<<std::endl; try{ MyString s3,s4,s5; //对象个数超过上限，会抛出出异常 }catch(ObjectCounter<MyString>::TooManyObjects& e){ std::cout<<"Too many MyString objects."<<std::endl; } Printer t1,t2,t3; std::cout<<"number of Printer: " <<Printer::objectCount()<<std::endl; std::cout<<"number of Printer: " <<t1.objectCount()<<std::endl; Printer t4,t5; //对象个数超过上限，会抛出出异常，终止程序 return 0; }

    这里ObjectCounter<T>模板用于计数，它需要作为基类，成员名的前面最好加类作用域符（也可用this->），使它变成依赖型名称。表示对象个数上限值的maxObjects成员是一个静态常量，它并没有初始化。我们必须在需要计数的类MyString、Printer中指定它的值。不同类的对象个数上限可能不同，因此我们只要特化maxObjects这个成员并指定需要的值即可（类模板可以只特化某个成员）。在MyString、Printer这些类中，由于是私有继承，因此要用using声明把objectCount函数变成公有，这样就可以用它来获取当前对象的个数。