类实例个数的限制

#include <exception>

#ifndef COUNT_HPP
#define COUNT_HPP 1
/*任何想用来限制自身对象数量的类可以继承此类 beCounted为该类名 size为计数尺寸
  任何继承该类的实现中必须给最大计数初始化
 例：
 template<class beCounted, class size> size base_count<beCounted,size>::maxObject=10;
 注：
 这个实现并不能解决多重继承计数的问题

*/
template <class beCounted,class size=int> class base_count
{
protected:
 base_count();
 base_count(const base_count &);
private:
 void init();
public :
 class too_many_object :public std::exception
 {
 public:
  too_many_object(const char * what):exception(what)
  {
  }
 };
public :
 typedef  size   SizeClass;
 typedef  too_many_object  ExceptionType;
 static   size  object_count()
 {
    return numObject;
 }
private:
 static size maxObject;
 static  size numObject;
};
/*初始计数为0*/
template<class beCounted, class size>size base_count<beCounted,size>::numObject=0;

template<class beCounted, class size> void base_count<beCounted,size>::init()
{
  if(numObject>=maxObject)
   throw too_many_object("object is out of count!");
  ++numObject;
}

template<class beCounted, class size> base_count<beCounted,size>::base_count()
{
 init();
}

template<class beCounted, class size>
base_count<beCounted,size>::base_count(const base_count &)
{
 init();
}

#endif  //COUNT_HPP

 

测试代码

#include "count.hpp"
#include <iostream>
using namespace std;

class A:private base_count<A>
{
public:
 using  base_count<A>::object_count;
 using  base_count<A>::too_many_object;
 using  base_count<A>::SizeClass;
 using  base_count<A>::ExceptionType;
};
 int base_count<A>::maxObject=4;

 class B:private base_count<B>,public A
{
};
 int base_count<B>::maxObject=4;
int main()
{  
 A  a;
 A  c;
 A  b;
 A  d;
 try
 {
 B  e;
 }
 catch(exception& e)
 {
  cout<<e.what();
 }
}