ring-buffer（C 语言实现）

        下面是一个 ring-buffer 的 C 语言实现，采用
Mirroring 方式实现空、满判断。通过 void 指针模拟泛型，可以在初始化时灵活定义 ring-buffer 中的元素类型（例如 char 类型，int 类型，数组类型，结构体类型等）。

        首先给出头文件定义：

/**
* File: ring_buf.h
*
* Description:
*   Header file for ring-buffer.
*   Implemented according to the 'Mirroring' solution:
*   http://en.wikipedia.org/wiki/Circular_buffer#Mirroring *
* Change Logs:
*   Date           Author       Notes
*   2013-12-16     Glen         first implementation
*/

#ifndef _RING_BUF_H_
#define _RING_BUF_H_

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>

#define IDX_MASK (SIZE_MAX>>1)
#define MSB_MASK (~IDX_MASK)   /* also the maximum value of the buffer depth */

/* ring buffer structure */
struct ring_buf
{
size_t depth ;             /* maximum element number */
size_t width ;             /* sizeof each element */
size_t rd_idx;             /* MSB is used for the 'mirror' flag */
size_t wr_idx;             /* MSB is used for the 'mirror' flag */
void   *buf  ;
};

typedef struct ring_buf  ring_buf_t;
typedef struct ring_buf* ring_buf_p;

bool ring_buf_init (ring_buf_p rbuf, size_t depth, size_t width);
void ring_buf_free (ring_buf_p rbuf);
void ring_buf_clear(ring_buf_p rbuf);

bool ring_buf_full (ring_buf_p rbuf);
bool ring_buf_empty(ring_buf_p rbuf);

bool ring_buf_write(ring_buf_p rbuf, void *wr_data);
bool ring_buf_read (ring_buf_p rbuf, void *rd_data);

#endif

        下面是对应的 C 文件：

/**
* File: ring_buf.c
*
* Description:
*   Ring-buffer implemented according to the 'Mirroring' solution:
*   http://en.wikipedia.org/wiki/Circular_buffer#Mirroring *
* Change Logs:
*   Date           Author       Notes
*   2013-12-16     Glen         first implementation
*/

#include "ring_buf.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>

/**
* @brief  Initialize the ring-buffer. Allocate necessary memory for the buffer.
*
* @param  rbuf : Pointer to the ring-buffer object
* @param  depth: Maximum element number of the buffer
* @param  width: sizeof each element
*
* @return true : Succeeded
*         false: Failed
*/
bool ring_buf_init(ring_buf_p rbuf, size_t depth, size_t width)
{
assert(depth > 0 && depth < MSB_MASK && width > 0);

rbuf->depth  = depth;
rbuf->width  = width;
rbuf->rd_idx = 0;
rbuf->wr_idx = 0;
rbuf->buf    = calloc(depth, width);
return rbuf->buf != NULL;
}

/**
* @brief  Release the ring-buffer object. Deallocate the buffer memory.
*
* @param  rbuf: Pointer to the ring-buffer object
*/
void ring_buf_free(ring_buf_p rbuf)
{
free(rbuf->buf);
rbuf->buf = NULL;
}

/**
* @brief  Clear the ring-buffer object.
*
* @param  rbuf: Pointer to the ring-buffer object
*/
void ring_buf_clear(ring_buf_p rbuf)
{
rbuf->rd_idx = 0;
rbuf->wr_idx = 0;
}

/**
* @brief  Whether the ring-buffer is empty or not.
*
* @param  rbuf: Pointer to the ring-buffer
*
* @return true : Empty. There's no elements stored in the buffer.
*         false: Not empty
*/
bool ring_buf_is_empty(ring_buf_p rbuf)
{
return rbuf->rd_idx == rbuf->wr_idx;
}

/**
* @brief  Whether the ring-buffer is full or not.
*
* @param  rbuf: Pointer to the ring-buffer
*
* @return true : Full
*         false: Not full
*/
bool ring_buf_is_full(ring_buf_p rbuf)
{
return (rbuf->rd_idx & IDX_MASK) == (rbuf->wr_idx & IDX_MASK) &&
(rbuf->rd_idx & MSB_MASK) != (rbuf->wr_idx & MSB_MASK);
}

/**
* @brief  Increase the buffer index while writing or reading the ring-buffer.
*         This is implemented according to the 'mirroring' solution:
*         http://en.wikipedia.org/wiki/Circular_buffer#Mirroring *
* @param  rbuf : Pointer to the ring-buffer
* @param  p_idx: Pointer to the buffer index to be increased
*/
inline void ring_buf_incr(ring_buf_p rbuf, size_t *p_idx)
{
size_t idx = *p_idx & IDX_MASK;
size_t msb = *p_idx & MSB_MASK;

if (++idx == rbuf->depth) {
msb ^= MSB_MASK;
idx = 0;
}
*p_idx = msb | idx;
}

/**
* @brief  Write new element to the ring-buffer.
*
* @param  rbuf   : Pointer to the ring-buffer object
* @param  wr_data: Pointer of the new element to be written to the buffer
*
* @return true : Succeeded
*         false: Failed
*/
bool ring_buf_write(ring_buf_p rbuf, void *wr_data)
{
if (ring_buf_is_full(rbuf))
return false;
else {
memcpy(rbuf->buf + rbuf->wr_idx * rbuf->width, wr_data, rbuf->width);
ring_buf_incr(rbuf, &rbuf->wr_idx);

return true;
}
}

/**
* @brief  Read from the ring-buffer
*
* @param  rbuf   : Pointer to the ring-buffer object
* @param  rd_data: Pointer to the read result
*
* @return true : Succeeded
*         false: Failed
*/
bool ring_buf_read(ring_buf_p rbuf, void *rd_data)
{
if (ring_buf_is_empty(rbuf))
return false;
else {
memcpy(rd_data, rbuf->buf + rbuf->rd_idx * rbuf->width, rbuf->width);
ring_buf_incr(rbuf, &rbuf->rd_idx);

return true;
}
}

        最后给出一个简单的应用示例，将字符数组写入 ring-buffer，然后读出、显示：

int main()
{
ring_buf_t rbuf;
char str[10];
ring_buf_init(&rbuf, 8, sizeof(str));

ring_buf_write(&rbuf, "str 0");
ring_buf_write(&rbuf, "str 1");
ring_buf_write(&rbuf, "str 2");
ring_buf_write(&rbuf, "str 3");

int k = 0;
for (k = 0; k < 8; k++)
if (ring_buf_read(&rbuf, str))
printf("%s\n", str);

ring_buf_free(&rbuf);

return 0;
}