两种封装模块方式的比较

一般情况下，我们用c++去写一个模块封装类，首要考虑的一个问题就是如何获取该模块的操作指针，在模块外部尽量减少限制和操作。多数情况我们去提供一个模块的静态方法，也可以理解为一个端口去得到本模块的指针，从而可以调用模块的的所有功能方法，包括初始化。下面总结两种封装方式的优劣：

第一种封装：

#include <stdio.h>
class test{
public:
	~test(){}
	void show(){
		printf("%d\n", this->i);
	}
	void set(int i){
		this->i = i;
	}
	static test* gettest(){
		static test tmp;
		return &tmp;
	}
private:
	int i;
	test():i(1){}
};
int main(){
	test* pt = test::gettest();
	pt->show();
	pt->set(2);
	pt = test::gettest();
	pt->show();
}

本方式的思想是这样的：首先提供一个静态取指针端口，即gettest。由于方法中静态变量在函数调用结束不会被释放掉，并且类的静态方法是由本类的虚表指针维护，与对象无关，所以该静态方法也是唯一的。由于静态方法唯一性，该静态方法里的静态对象不被释放，所以可以利用这一特点把该静态成员作为模块的实际对象来操作。其次为了保证在类外部不允许用户去构建本类的对象，所以要把构造方法设定为私有。这样外部只允许唯一的获取模块指针的方法，即：类名::静态端口

第二种封装：

#include <stdio.h>
class testb{
public:
	~testb(){}
	void show(){
		printf("%d\n", this->i);
	}
	void set(int i){
		this->i = i;
	}
	static testb* gettestb(){
		return &tmp;
	}
private:
	static testb* tmp;  //此处为模块对象的声明
	int i;
	testb():i(1){}
};
testb* testb::tmp = new testb();   //此处为模块对象的定义，也是在此处才会真正的实例化
int main(){
	testb *ptb = testb::gettestb();
	ptb->show();
	ptb->set(2);
	ptb = testb::gettestb();
	ptb->show();
}

本方式的思想是这样的：首先也要提供一个唯一的静态取指针的端口，即gettestb。然后考虑到类的静态成员与本类的对象无关性，利用该特点把本模块的对象封装成静态成员，由静态端口获取。为了不允许通过除了端口外的其他方式获取，所以把该静态成员设定为私有。同样，为了保证在外部不允许用户构造本类的对象，所以构造方法设定为私有。这样外部也只允许唯一的获取模块指针方法，即：类名::静态端口

对比这两种方式的差异：对于第一种方式程序在运行时候第一次调用获取类模块方法时候，才去真正的构造该模块的对象。对于第二种方式，编译器编译时候已经为该模块实例化了对象，在程序运行的时候，内存就会开辟了。所以，通常为了内存问题，即模块不加载就不开辟内存的原则，我们多数采用第一种方式封装更好。

附加知识：

静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为 所属类类型的 指针或引用。举例如下：

class base{ 
public : 
static base _object1;//正确，静态数据成员 
base _object2;//错误 
base *pObject;//正确，指针 
base &mObject;//正确，引用 
}; 

因为如果在类内部允许实例化本类类型的话，这样在实例化一个类对象时候，会无限递归实例化。所以也证明，类静态成员在类内部的代码，仅仅是声明，真正定义必须在类外。