Question

作为练习，我希望创建一个不能超过N个实例的类。我怎么能这样做？

例如，假设您要限制与数据库的连接数，以便不超过N个用户可以同时连接。我理解如何制作单身人士：

class Singleton {

private:

    Singleton(const Singleton&);

    Singleton();

public :

    static Singleton Instance() {

         static Singleton p;

         if(!p) {

                p = new Singleton;

         }
};

但如果有N＆gt; 1个对象，我需要帮助。

Answer 1

首先，为什么？

一旦我们解决了这个问题，你就会知道如何创建一个只允许一个实例的类，我假设？通常，您使用静态实例和私有构造函数（或其某些变体）来执行此操作。要将其概括为N个实例，您需要做的就是存储实例的静态数组。

最后，严肃地说，为什么？

Answer 2

使用名为count的静态变量。在构造函数中，每次创建对象时只需添加一个：

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

Answer 3

我能看到这样的事情的唯一目的是创建一个“工人”池（或类似的东西）。实现此目的的最佳方法是创建两个类：一个“WorkerPool”类和一个“Worker”类。像这样：

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;

}

这只是一个例子，你可以采用不同的方式（包括使WorkerPool成为单例，同步get（）而不是返回NULL等） - 但是你得到了图片。

Answer 4

首先，代码“public”的编译和工作版本是：

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

为了练习，您可以使用

修改为N个实例

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

错误检查被忽略。

Answer 5

使用固定大小的数组？

Answer 6

使用工厂方法创建实例。在类中还有一个static变量，用于跟踪存在的实例数。如果达到上限，则可以抛出异常或返回已创建的对象，具体取决于您的设计。要仅通过工厂方法创建对象，您必须创建ctor private。

Answer 7

除非100％有意义将该类限制为N个实例，否则你应该将该类封装到静态访问类中，这几乎不会限制实例数。

如何限制类的实例数？

7 个答案: