技术（2）—限制某个class所能产生的对象数量

Item26 限制某个class所能产生的对象数量。

（1）0个：将构造函数声明为private。

（2）1个：Sigleton模式。

（3）指定个数，方法如下：

写一个基类，用来对象计数：

Counted.h

template <typename T>
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 <typename T>
Counted<T>::Counted()
{
	Init();
}

template <typename T>
Counted<T>::Counted(const Counted& rhs)
{
	Init();
}
template <typename T>
void Counted<T>::Init()
{
	if(numObjects>=maxObjects)
		throw TooManyObjects();
	++numObjects;
};

假设我们有10台打印机，定义打印机的类如下：

template <typename T>
int Counted<T>::numObjects=0;

class Printer : private Counted<Printer>
{
public:
	static Printer* makePrinter();
	static Printer* makePrinter(const Printer& rhs);

	~Printer();

	using Counted<Printer>::objectCount;
	using Counted<Printer>::TooManyObjects;
private:
	Printer();
	Printer(const Printer& rhs);
};

Printer::Printer()
{
	cout<<"Printer()"<<endl;
}

Printer::Printer(const Printer& rhs)
{
	cout<<"Printer(const Printer& rhs)"<<endl;
}

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

Printer* Printer::makePrinter(const Printer& rhs)
{
	return new Printer(rhs);
}

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

int main(int argc, char* argv[])
{
	Printer *p1=Printer::makePrinter();
	Printer *p2=Printer::makePrinter();
	Printer *p3=Printer::makePrinter(*p2);

	cout<<Printer::objectCount()<<endl;

	return 0;
}

注意Counted类的两个static数据成员的初始化位置。通过maxObjects我们可以指定资源的上限。
当资源上限为1的时候，效果同sigleton模式。

另外，将某个类的构造函数声明为private，除了防止不能被创建对象，也能防止被派生。