Question

我试图写一个从我的currentIndex变量离开的地方开始的for循环，然后遍历循环缓冲区。

我正在使用循环缓冲区来存储加载数据。定期存储数据。

目前，这是我填充数据的方式：

//currentIndex starts at 0
buffer[currentIndex] = data;
currentIndex = (currentIndex + 1) % size;

例如：大小为6.存储8个条目（1 2 10 11 12 13 8 9），因此索引0和1的2个条目将被覆盖。

指数：0 1 2 3 4 5

缓冲区：8 9 10 11 12 13

填充9后，currentIndex变为2。我想按此顺序遍历指数：9,8,13,12,11,10。我想从填充的最后一个索引（最新数据）开始。

我无法想出在for循环中执行此操作的逻辑。

Answer 1

如果要从最后一个索引值之前的元素开始打印，可以使用递减非零数组索引的do循环，或者将最后一个可用索引分配给数组索引： / p>

#include <stdio.h>

int main(void)
 {
     size_t size = 6;
     int buffer[size];
     int input[] = { 1, 2, 10, 11, 12, 13, 8, 9 };

     /* Populate array */
     size_t currentIndex = 0;
     size_t lastIndex = 0;
     for (size_t i = 0; i < 8; i++) {
         buffer[currentIndex] = input[i];
         currentIndex = (currentIndex + 1) % size;
         lastIndex = currentIndex;
     }

     /* Print array contents */
     for (size_t i = 0; i < size; i++) {
         printf("%5d", buffer[i]);
     }
     putchar('\n');

     /* Print in reverse, starting before the last index */
     size_t i = lastIndex;
     do {
         i ? --i : (i = size - 1);
         printf("%5d", buffer[i]);
     } while (i != lastIndex);
     putchar('\n');

     return 0;
 }

节目输出：

8    9   10   11   12   13
9    8   13   12   11   10

Answer 2

有理由为堆栈使用循环缓冲区。一个使用循环缓冲区来实现一个写入器和一个读取器的无锁队列。

int head = 0;
int tail = 0;
int buffer[BUF_SIZE];  // Holds one less than BUF_SIZE elements.

// Returns true if successful, false if empty.
int circular_buffer_read(int* val_ptr) {
   if (head == tail)
      return 0;

   *val_ptr = buffer[tail];
   tail = (tail + 1) % BUF_SIZE;
   return 1;
}

// Returns true if successful, false if full.
int circular_buffer_write(int val) {
   buffer[head] = val;
   int new_head = (head + 1) % BUF_SIZE;
   if (new_head == tail)
      return 0;

   head = new_head;
   return 1;
}

如果您有一个阅读器和一个编写器，如果比较（head == tail和new_head == tail）是线程安全的，则上述内容是线程安全的。

void producer() {
   int i = 0;
   while (1) {
      if (!circular_buffer_write(i)) {
         sleep(1);
         continue;
      }

      ++i;
   }
}

void consumer() {
   while (1) {
      int i;
      if (!circular_buffer_read(&i)) {
         sleep(1);
         continue;
      }

      printf("Got %d\n", i);
   }
}

Answer 3

您似乎需要一种LIFO类型的结构，而不是通常用于FIFO的循环缓冲区（队列）。

堆栈可能更适合您的用例。

当生产者将元素放在堆栈顶部时，消费者从同一个顶部取出元素，首先处理最新元素。

Answer 4

for(int i = size; i > 0; --i)
{
    printf("%d ", buffer[(currentIndex + i) % size]);
}

指数计算：

(currentIndex + size    ) % size ~ currentIndex
(currentIndex + size - 1) % size ~ currentIndex - 1
...

循环缓冲区遍历

4 个答案: