如何限制一个类的实例数？

Question

As an exercise, I wish to make a class that can't have more than N instances. How can I do that?

Suppose, for example, you want to limit number of connection to database so that no more than N users can connect at the same time. I understand how to make a singleton:

class Singleton {

private:

    Singleton(const Singleton&);

    Singleton();

public :

    static Singleton Instance() {

         static Singleton p;

         if(!p) {

                p = new Singleton;

         }
};

But if there N > 1 objects, I need help.

Answer 1

First of all, why ?

Once we get that question out of the way, you already know how to make a class that allows for just one instance, I assume? Usually, you do that with a static instance and a private constructor (or some variation thereof). To generalise that to N instances, all you need to do is store a static array of instances.

Finally, seriously, WHY ?

Answer 2

Use a static variable that is called count for example. In the constructor just add one each time an object is created:

struct myclass
{
  myclass()
  {
    if(count == N) /*throw some exception!*/
    ++count;
  }
  ~myclass()
  {
    --count;
  }
private:
  static std::size_t count = 0;
};

Answer 3

The only purpose I can see for something like this is to create a pool of "workers" (or something similar). The best way to achieve this is to create two classes: one "WorkerPool" class and one "Worker" class. Something like this:

typedef boost::shared_ptr<Worker> WorkerPtr;

class Worker{
   // do the worker stuff here
}

class WorkerPool{
   public:
     const int MAX_WORKERS = 20;
     WorkerPool(){ for(int i=0;i<MAX_WORKERS;i++)
                        _pool.push_back(WorkerPtr(new Worker()) );
                  }

     WorkerPtr get(){
          if(_pool.size()>0) return _pool.pop_front();
          return WorkerPtr();
     }    

     void release(WorkerPtr w){
          return _pool.push_back(w);
     }    

     private:
       std::list<WorkerPtr> _pool;

}

It's just an example, you may do it differently (including making the WorkerPool a singleton, synchronizing get() instead of returning NULL, etc.) - but you get the picture.

Answer 4

First, a compiling and working version of the code "public" is:

static Singleton*  Instance() {
  static Singleton *p;
  if(!p) { p = new Singleton; }
  return p;
}

For the sake of the exercise, you could modify to N instances by using

static Singleton* Instance(int n) {
  static Singleton *p[N];
  if(!p[n]) { p[n] = new Singleton; }
  return p[n];
}

Error checking omitted.

Answer 5

使用固定大小的数组？

Answer 6

Use a factory method for instance creation. Also have a static variable in the class to to keep track of number of instances in existence. If the upper limit is hit you can trow an exception or return an already created object, depends on your design. To enable object creation only through the factory method you'll have to make the ctor private .

Answer 7

除非该类将自身限制为N个实例100％有意义，否则您应该真正将该类包装到一个静态访问类中，该类几乎不会限制实例的数量。