共享内存上的c++内存池实现:这种分配和释放的方法是否正确?

我可以要求我的任何回应者只考虑"纯"C/c++(无论这意味着什么)吗?STL没问题。

我正在编写自己的c++内存池类(在Linux系统上)，用于在共享内存中分配和释放c++对象。我需要通过多个进程访问相同的对象。我将使用POSIX信号量控制对内存池对象操作的访问，但是我有一个基本的分配/释放问题。我的代码只适用于从同一池中分配的相同大小的对象。目前，我们可以忽略与池的动态增长和收缩相关的问题。

考虑我有一个共享内存段定义了MAXFOOOBJECTS Foo对象的总数。我以以下方式定义共享内存段:

int shmid = shmget (somekey, ((sizeof(Foo) + 4) * MAXFOOOBJECTS) + 4, correctFlags);
void* sMem = shmat (shmid, (void*)0, 0);

对于所有使用这个共享内存的进程，内存将被这样解释:

struct SharedMemStructure
{
   int numberOfFooObjectsInPool;
   Foo* ptrArray [MAXFOOOBJECTS]; // Pointers to all the objects in the array below
   Foo objects [MAXFOOOBJECTS]; // Same as the value in the shmget call
};

假设我有一个对象Foo，定义如下:

<Foo.h> 
class Foo
{
   public:
     Foo ();
     ~Foo ();
     void* operator new (); // Will allocate from shared memory
     void operator delete (void* ptr); // Will deallocate from shared memory
   private:
     static void* sharedMem; // Set this up to be a POSIX shared memory that accesses
                      // the shared region in memory
     static int shmid;
}
<Foo.cpp>
int Foo::shmid = shmget (somekey, ((sizeof(Foo) + 4) * MAXFOOOBJECTS) + 4, correctFlags);
void* Foo::sharedMem = shmat (shmid, (void*)0, 0);
void* Foo::operator new ()
{
   void* thisObject = NULL;
   sem_wait (sem); // Implementation of these is not shown
   // Pick up the start of a chunk from sharedMem (will make sure this
   // chunk has unused memory...
   thisObject = (sharedMem + 4 + 4 * MAXFOOOBJECTS + 
                (sizeof (Foo) * sharedMem->numberOfFooObjectsInPool);
   sharedMem->ptrArray[numberOfFooObjectsInPool] = thisObject;
   sharedMem->numberOfFooObjectsInPool ++;
   sem_post (sem);
   return thisObject;
}
void Foo::operator delete (void* ptr)
{
   int index = 0;
   sem_wait (sem); // Implementation of these is not shown
   // Swap the deleted item and the last item in the ptrArray;
   index = (ptr - (sharedMem + 4 + (4*MAXFOOOBJECTS)))/(sizeof(Foo));
   ptrArray[index] == ptrArray[numberOfFooObjectsInPool - 1];
   numberOfFooObjectsInPool --;
   sem_post (sem);
}

我的问题是:

1. 前面提到的方案对你们来说还行吗(每个新建和删除都是0(1))，还是我遗漏了一些非常重要的东西?我立即看到的一个问题是，如果Foo对象数组被解释为最小堆，例如，每次执行new和delete操作时，我都会杀死堆属性。
2. 如果我保证这个池不会被用于最小堆(比如，定时器管理技术需要)，我们对上述方案有任何问题吗?
3. 另一方面，我可以将共享内存中的Foo数组管理为最小或最大堆(即，在新建和删除期间)，并且每次新建或删除都会导致O (lgn)最坏情况。任何评论?
4. 还有其他更好的方法吗?