使用指针在 C 数组中排队

Question

我尝试用 C 语言通过数组和指针来实现队列。队列 采用C结构建模

// Circular Buffer
typedef struct{
    main_controller_req_t     buffer[BUFFER_SIZE];   // buffer
    uint16_t                  size;                  // length of the queue
    uint16_t                  count;                 // number of elements present in the queue
    main_controller_req_t     *p_head;               // pointer to head of the queue (read end)
    main_controller_req_t     *p_tail;               // pointer to tail of the queue (write end)
}circular_buffer_t;

我已经实现了队列初始化函数

void init_cb(circular_buffer_t *p_cb){

    p_cb->p_head = p_cb->buffer;
    p_cb->p_tail = p_cb->buffer;
    p_cb->count = 0;
    p_cb->size = BUFFER_SIZE;

}

插入队列的函数

BOOL enqueue_cb(circular_buffer_t *p_cb, main_controller_req_t *p_enq_elem){

    if(p_cb->count < p_cb->size){

        // queue contains at least one free element

        taskENTER_CRITICAL();

            // insert the element at the tail of queue
            *(p_cb->p_tail) = *p_enq_elem;
            // incrementing modulo size
            p_cb->p_tail = (((p_cb->p_tail++) == (p_cb->buffer + p_cb->size)) ? (p_cb->buffer) : (p_cb->p_tail));
            // one element added
            p_cb->count++;

        taskEXIT_CRITICAL();

        return TRUE;

    }else{

        // queue is full
        return FALSE;

    }

}

enqueue_cb 函数运行良好，直到尾部达到 BUFFER_SIZE。然后 程序崩溃和 uC 重置。问题出在 p_tail 指针更新中，但我没有 明白为什么。请问有人可以帮我吗？提前致谢。

Answer 1

问题出在您的测试中...您检查是否溢出，但在增加指针之前，这会导致p_cb->p_tail越过循环缓冲区的末尾。

 p_cb->p_tail = ((p_cb->p_tail++) == (p_cb->buffer + p_cb->size)) 
                    ? (p_cb->buffer) 
                    : (p_cb->p_tail);

你必须在 递增之后测试 tail 的值。

 p_cb->p_tail = (++(p_cb->p_tail) >= (p_cb->buffer + p_cb->size)) 
                    ? p_cb->buffer 
                    : p_cb->p_tail;

顺便说一句，链表并不是实现循环缓冲区的一种非常有效的方式。您是否考虑过使用简单的 fifo 缓冲区实现？

fifo 结构非常常见，因此为 C 提供 通用 宏实现很有用。如果您只有一个生产者和一个消费者，它是线程安全的（不需要锁）。

这些宏很容易被编译器优化。

这是一个很好的工具。

// save these macros in a header file.
#define fifo_reset(fifo) \
     { (fifo).head = (fifo).tail = (fifo).buffer; }

#define fifo_elements(fifo) \
    (sizeof((fifo).buffer) / sizeof((fifo).buffer[0])

#define fifo_count(fifo) \
    (((fifo).tail >= (fifo).head)) ? ((fifo).tail - (fifo).head) : (((fifo).tail - (fifo).head) + fifo_elements(fifo))

#define fifo_free_space(fifo) \
    (fifo_elements(fifo) - (fifo_count(fifo) + 1))

#define __fifo_advance(fifo, ptr) /* this is "private" */\
    (( ((ptr) + 1) < (fifo).buffer + fifo_elements(fifo))) ? ((ptr) + 1) : (fifo).buffer )

#define fifo_full(fifo) \
    (__fifo_advance(fifo, (fifo).head) == (fifo).tail)

#define fifo_empty(fifo) \
    ((fifo).head == (fifo).tail)

#define fifo_pop(fifo, el)  \
    ( (fifo).head = ((el) = *(fifo).head, __fifo_advance(fifo, (fifo).head)) )

#define fifo_push(fifo, el)  \
    ( (fifo).tail = (*((fifo).tail) = (el), __fifo_advance(fifo, (fifo).tail)) )

// Now, any struct with head, tail, and fixed-length buffer is a fifo.
struct char_fifo_128
{
  char buffer[128];  
  char* head;
  char* tail;
};

struct main_controller_req_t
{
    // all data types are _movable_ using '='
    char any[128];
    int data;
    float more_data;
    char* dupstr;
};

#define BUFFER_SIZE 256

struct controller_fifo
{
  main_controller_req_t     buffer[BUFFER_SIZE];   // buffer
  main_controller_req_t*    head;
  main_controller_req_t*    tail;
};

int main()
{
  char c = 0;
  int elements_stored;
  controller_fifo queue;
  main_controller_req_t req;

  fifo_reset(queue);  // MUST call before using fifo

  // always check if space/data is available.
  if (!fifo_full(queue))
  {
      fifo_push(queue, req);
  }
  elements_stored = fifo_count(queue);

  if (!fifo_empty(queue))
  {
      fifo_pop(queue, req);
  }

  fifo_reset(queue);   // fifo reset is NOT thread-safe


  char_fifo_128* buffer = (char_fifo_128*)malloc(sizeof(char_fifo_128));

  fifo_reset(*buffer);

  if (!fifo_full(*buffer))
  {
      // ...
      fifo_push(*buffer, req);
  }
  elements_stored = fifo_count(*fifo);

  if (!fifo_empty(*buffer))
  {
      fifo_pop(*buffer, c);
  }

  free(buffer);
  return 0;
}