2

我正在构建一个简单的粒子系统，并希望使用结构的单个数组缓冲区来管理我的粒子。也就是说，我找不到允许我从任意缓冲区进行 malloc() 和 free() 的 C 函数。这是一些伪代码来显示我的意图：

Particle* particles = (Particle*) malloc( sizeof(Particle) * numParticles );
Particle* firstParticle = <buffer_alloc>( particles );
initialize_particle( firstParticle );
// ... Some more stuff
if (firstParticle->life < 0)
    <buffer_free>( firstParticle );

// @ program's end
free(particles);

where<buffer_alloc>和<buffer_free>are 从任意指针分配和释放内存块的函数（可能带有额外的元数据，例如缓冲区长度等）。是否存在此类功能和/或是否有更好的方法来做到这一点？谢谢！

4

5 回答 5

5

是的，你必须自己写。它是如此简单，它真的很傻，但与一直简单地使用 malloc() 和 free() 相比，它的性能会尖叫......

static const int maxParticles = 1000;

static Particle particleBuf[maxParticles]; // global static array

static Particle* headParticle;

void initParticleAllocator()
{
    Particle* p = particleBuf;
    Particle* pEnd = &particleBuf[maxParticles-1];
    // create a linked list of unallocated Particles
    while (p!=pEnd)
    {
        *((Particle**)p) = p+1;
        ++p;
    }
    *((Particle**)p) = NULL; // terminate the end of the list
    headParticle = particleBuf; // point 'head' at the 1st unalloc'ed one
}

Particle* ParticleAlloc()
{
    // grab the next unalloc'ed Particle from the list
    Particle* ret = headParticle;
    if (ret)
        headParticle = *(Particle**)ret;
    return ret; // will return NULL if no more available
}

void ParticleFree(Particle* p)
{
    // return p to the list of unalloc'ed Particles
    *((Particle**)p) = headParticle;
    headParticle = p;
}

您可以修改上面的方法，根本不从任何全局静态数组开始，并在用户调用 ParticleAlloc() 时首先使用 malloc()，但是当返回 Particles 时，不要调用 free() 而是添加返回的那些到未分配粒子的链表。然后 ParticleAlloc() 的下一个调用者将从空闲 Particles 列表中获取一个，而不是使用 malloc()。任何时候空闲列表中都没有更多内容时，您的 ParticleAlloc() 函数可能会退回到 malloc()。或者混合使用这两种策略，这确实是两全其美：如果您知道您的用户几乎肯定会使用至少 1000 个粒子，但偶尔可能需要更多，您可以从 1000 的静态数组开始，然后如果您用完了，请返回调用 malloc() 。如果你这样做，malloc()' ed 不需要特殊处理；当它们返回到 ParticleFree() 时，只需将它们添加到您的未分配粒子列表中。当您的程序退出时，您无需费心在它们上调用 free() ；操作系统将释放进程的整个内存空间，因此任何泄漏的内存都会在此时清除。

我应该提到，由于您的问题被标记为“C”而不是“C++”，因此我以 C 解决方案的形式回答了它。在 C++ 中，实现相同功能的最佳方法是在 Particle 类中添加“operator new”和“operator delete”方法。它们将包含与我上面显示的基本相同的代码，但它们覆盖（而不是重载）全局“new”运算符，并且仅对于 Particle 类，定义一个替换全局“new”的专用分配器。很酷的是，粒子对象的用户甚至不必知道有一个特殊的分配器；他们只是像往常一样简单地使用“new”和“delete”，并且很高兴地没有意识到他们的 Particle 对象来自一个特殊的预分配池。

于 2012-06-24T21:28:07.260 回答
1

哦对不起。这个问题只有我看到的C。不是 C++。好吧，如果它是 C++，那么下面的内容会帮助你。

查看Boost 的池分配库。

在我看来，您的每个分配都是相同的大小？粒子的大小，对吗？如果是这样，来自 Boost 的池分配函数将运行得非常好，您不必自己编写。

于 2012-06-24T21:35:56.343 回答
0

你必须自己写，或者找一个已经写过它们的人并重用他们写的东西。AFAIK 没有标准的 C 库来管理该场景。

您的“缓冲区分配”代码可能需要 4 个函数：

typedef struct ba_handle ba_handle;

ba_handle *ba_create(size_t element_size, size_t initial_space);
void  ba_destroy(ba_handle *ba);

void *ba_alloc(ba_handle *ba);
void  ba_free(ba_handle *ba, void *space);

create 函数将进行空间的初始分配，并安排以element_size. 返回的句柄允许您为不同类型（甚至为同一类型多次）分配单独的缓冲区。destroy 函数强制释放与句柄关联的所有空间。

分配功能为您提供了一个新的空间单位供您使用。free 函数释放它以供重用。

在幕后，代码会跟踪正在使用的单元（可能是位图），并且可能会根据需要分配额外的空间，或者可能会在初始分配用完时拒绝空间。您可以安排它在空间不足时或多或少地失败（因此分配器永远不会返回空指针）。显然，free 函数可以验证给它的指针是由当前正在使用的缓冲区分配器句柄提供的指针。这允许它检测一些常规free()通常不会检测到的错误（尽管malloc()et al 的 GNU C 库版本似乎确实做了一些其他人不一定做的完整性检查）。

于 2012-06-24T21:04:36.983 回答
0

也许尝试这样的事情......

Particle * particles[numParticles];
particles[0] = malloc(sizeof(Particle));
initialize_particle( particle[0] );

// ... Some more stuff
if (particle[0]->life < 0)
    free( particle[0] );

// @ program's end
// don't free(particles);
于 2012-06-24T21:12:16.817 回答
-1

我正在构建一个简单的粒子系统，并希望使用结构的单个数组缓冲区来管理我的粒子。

我想你已经回答了：

static Particle myParticleArray[numParticles];

在程序开始时分配并在结束时释放，很简单。或者喜欢你的伪代码并同时 malloc 数组。你可能会问自己为什么要分配一个粒子，为什么不分配整个系统？编写您的 API 函数以获取指向粒子数组和索引的指针。

于 2012-06-24T21:41:12.083 回答