类的嵌套以及类的私有构造函数

在C++中“类的嵌套”以及“私有构造函数”是不是大家都不常用啊？下面先看一个例子吧：

• #include <iostream>
• using namespace std;
• template< typename T >
• //注意一点static成员是独立于类而存在的。
• class Singleton
• {
•     //类的嵌套定义
•     class InstanceHolder
•     {
•     public:
•         InstanceHolder() : mObject(0) {}
•         ~InstanceHolder() { delete mObject; }
•         T* set(T* p) { delete mObject; mObject = p;return mObject; }
•     private:
•         T* mObject;
•     };
• public:
•     //这里也是用的static
•     static T* instance()
•     {
•         return mInstance.set(new T());
•     }
•     
• private:
•     //这里定义了私有的构造函数
•     Singleton();
•     //嵌套定义类的实例，注意这里是在private里面，而且用的是static
•     static InstanceHolder           mInstance;
• };
• //下面两句要看清楚啊！！！了解typename的用法（详见下一篇）
• //初始化static成员，是不是看起来有些别扭啊，如果你知道了typename的用法就会
• //明白下面两句的意思了
• template< typename T >
• typename Singleton<T>::InstanceHolder Singleton<T>::mInstance;
• class        ServiceListener
• {
• public:
•         virtual ~ServiceListener()
•         { }
•         virtual void serviceStarted() = 0;
•         virtual void serviceStopped() = 0;
• };
• void ServiceListener::serviceStarted()
• {
•         printf("serviceStarted() event listener is not implemented.");
• }
• void ServiceListener::serviceStopped()
• {
•         printf("serviceStarted() event listener is not implemented.");
• }
• class ServiceController;
• typedef Singleton<ServiceController> ServiceKontrol;
• class ServiceController : public ServiceListener
• {
• public:
•         ServiceController();
•         ~ServiceController();
•         virtual void serviceStarted();
•         virtual void serviceStopped();
• private:
•         bool started;
• };
• ServiceController::ServiceController() : started(false)
• {
• }
• ServiceController::~ServiceController()
• {
• }
• void
• ServiceController::serviceStarted()
• {
•         printf("service start/n");
• }
• void
• ServiceController::serviceStopped()
• {
•         printf("servicestop/n");
• }
• int main(int argc, char **argv)
• {
•         int num=0;
•         //因为一开始在类的声明中就将instance()声明为static,
•         //所以它可以不实例化Singleton类，而直接调用
•         ServiceKontrol::instance()->serviceStarted();
•         ServiceController test;
•         test.serviceStarted();
•         //下面这句是不会定义成功的，因为它的构造函数是private的
• //      ServiceKontrol isok;
•         std::cin >> num;
•         return 0;
• }

上面的例子看的怎么样？是不是有些迷糊啊，呵呵，有些东西之所以难是因为你并没有真正了解它！好，让我们先理论知识吧：

C++ 类的构造函数一般是public的，但是也可以是private的。
类中定义了私有构造函数后:

1. 不能实例化：因为实例化时，类外部无法访问其内部的私有构造函数;

2. 不能继承： 理由与1相同。

通常我们都将构造函数的声明置于public区段，假如我们将其放入private区段中会发生什么样的后果？没错，我也知道这将会使构造函数成为私有的，这意味着什么？

我们知道，当我们在程序中声明一个对象时，编译器为调用构造函数(如果有的话)，而这个调用将通常是外部的，也就是说它不属于class对象本身的调用，假如构造函数是私有的，由于在class外部不允许访问私有成员，所以这将导致编译出错。

你于是说：“哈哈。”我们制造了一个似乎无法产生对象的class.哦，当然，对于class本身，我们还可以利用它的static公有成员，因为它们独立于class对象之外，我们不必产生对象也可以使用它们。嗯，看来我们还是为带有私有构造函数的类找到了一个存在的理由。不过我们不应当满足于此，因为看上去应当还有发掘的余地。

首先我们来认真看一下是不是真的无法创建出一个具有私有构造函数的类对象。“呃，可能未必。”你现在也许会这样说。这很好，让我们再来看看为什么，没错，因为构造函数被class私有化了，所以我们要创建出对象，就必须能够访问到class的私有域；但这一点“我们”是做不到的，那么，谁能做得到呢？class的成员可以做得到；但在我们建构出其对象之前，怎么能利用它的成员呢？噢，刚才我们刚刚提到了static公有成员，它是独立于class对象而存在的，当然，它也是公有的，“我们”可以访问得到。假如在某个static函数中创建了该class的对象，并以引用或者指针的形式将其返回(不可以以值的形式返回，想想为什么)，我们就获得了这个对象的使用权。下面是例子：

• class WonderfulClass
• {
• public:
•        static WonderfulClass* makeAnObject()
•        {
•               // 创建一个WonderfulClass对象并返回其指针
•               return (new WonderfulClass);
•        }
• private:
•        WonderfulClass() { }
• };
• int main()
• {
•        WonderfulClass *p = WonderfulClass::makeAnObject();
•        ... // 使用*p
•        delete p;  // Not neccesary here, but it's a good habit.
•        return 0;
• }

嗯，这个例子使用了私有构造函数，但它运行得很好:makeAnObject()作为WonderfulClass的静态成员函数，尽心尽责地为我们创建对象：由于要跨函数传递并且不能使用值传递方式，所以我们选择在堆上创建对象，这样即使退出，对象也不会随之蒸发掉，当然，使用完之后你可不要忘了手工将它清除。

回到前面的思路：除了公有的static成员可以帮助我们访问私有域外，还有没有其它可以利用的东西？

噢，你一定想到了使用友元，完全正确。可以使用该类的友元函数或者友元类创建其对象，这里就不举例了。

我们知道没有人会无聊到无缘无故把一个设为私有，然后再写一个和上面一模一样的makeAnObject()来让它的用户体验一下奇特的感觉。我们也不太相信这只是由于C++的设计原因而导致的一个顺便的、特殊的、无用的、边角功能。它应当是有实际用途的。提醒一下，到了JAVA中你会更容易明白很多静态方法创建对象的原理！！！

嗯，例如，我们想实现这样一个class：它至多只能存在一个，或者指定数量个的对象还记得标准输入输出流库中那个独一无二的吗？)，我们可以在class的私有域中添加一个static类型的计数器，它的初值置为0，然后再对makeAnObject()做点手脚：每次调用它时先检查计数器的值是否已经达到对象个数的上限值，如果是则产生错误，否则才new出新的对象，同时将计数器的值增1.最后，为了避免值复制时产生新的对象副本，除了将构造函数置为私有外，复制构造函数也要特别声明并置为私有。