如何在 C 中实现循环缓冲区？

我需要一个固定大小（在创建时可以在运行时选择，而不是编译时选择）的循环缓冲区，它可以容纳任何类型的对象，并且需要very高性能。我认为不会出现资源争用问题，因为尽管它处于多任务嵌入式环境中，但它是一个合作环境，因此任务本身可以管理它。

我最初的想法是在缓冲区中存储一个简单的结构，其中包含类型（简单枚举/定义）和指向有效负载的空指针，但我希望它尽可能快，因此我愿意接受涉及绕过的建议堆。

实际上，我很高兴绕过任何标准库来提高原始速度 - 从我所看到的代码来看，它并没有针对 CPU 进行大量优化：看起来他们只是为类似的事情编译了 C 代码strcpy()因此，没有手工编码的汇编。

任何代码或想法将不胜感激。所需的操作是：

• 创建一个具有特定大小的缓冲区。
• 放在尾巴上。
• 从头部得到。
• 返回计数。
• 删除一个缓冲区。

最简单的解决方案是跟踪项目大小和项目数量，然后创建适当字节数的缓冲区：

typedef struct circular_buffer
{
    void *buffer;     // data buffer
    void *buffer_end; // end of data buffer
    size_t capacity;  // maximum number of items in the buffer
    size_t count;     // number of items in the buffer
    size_t sz;        // size of each item in the buffer
    void *head;       // pointer to head
    void *tail;       // pointer to tail
} circular_buffer;

void cb_init(circular_buffer *cb, size_t capacity, size_t sz)
{
    cb->buffer = malloc(capacity * sz);
    if(cb->buffer == NULL)
        // handle error
    cb->buffer_end = (char *)cb->buffer + capacity * sz;
    cb->capacity = capacity;
    cb->count = 0;
    cb->sz = sz;
    cb->head = cb->buffer;
    cb->tail = cb->buffer;
}

void cb_free(circular_buffer *cb)
{
    free(cb->buffer);
    // clear out other fields too, just to be safe
}

void cb_push_back(circular_buffer *cb, const void *item)
{
    if(cb->count == cb->capacity){
        // handle error
    }
    memcpy(cb->head, item, cb->sz);
    cb->head = (char*)cb->head + cb->sz;
    if(cb->head == cb->buffer_end)
        cb->head = cb->buffer;
    cb->count++;
}

void cb_pop_front(circular_buffer *cb, void *item)
{
    if(cb->count == 0){
        // handle error
    }
    memcpy(item, cb->tail, cb->sz);
    cb->tail = (char*)cb->tail + cb->sz;
    if(cb->tail == cb->buffer_end)
        cb->tail = cb->buffer;
    cb->count--;
}