需求描述：實現一個固定長度的字元快取管理結構，實現字串的寫入和讀出。

1）佇列加資料，向cb尾追加長為length的字串，存在putting中； 當緩衝剩餘空間remain<length時，追加長為remain的字串，函式返回實際有效存放到緩衝中的字串；

2）佇列取資料，在cb中讀取長度為length的字串，存於getting中；當佇列存放的字元數used<length時，只讀取長為used的字串，讀取字串後，佇列中相應緩衝不再使用。

特別宣告，本文原始碼在VC6.0上測試通過。

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>

// 定義佇列緩衝長度，實際長度為SIZE-1
#define SIZE 10

// 定義陣列迴圈佇列
typedef struct cb_s
{
 char *queue;
 unsigned long front;
 unsigned long rear;
}cb_t;

void cbInit(cb_t **cb, unsigned long size);                          // 佇列初始化函式
unsigned long cbPuts(cb_t *cb, char *putting, unsigned long length); // 佇列加資料函式
char *cbGets(cb_t *cb, unsigned long length, char *getting);         // 佇列取資料函式
void cbDestroy(cb_t *cb);                                            // 佇列釋放函式

void main(void)
{
 cb_t *pcb = NULL;
 char *putting = "a+b#c*d-e!f&g";
 char getting[SIZE] = {0};

 cbInit(&pcb, SIZE);

 printf("Test of [cbPuts] operation>>\n");
 printf("%d\n\n", cbPuts(pcb, putting, 12));

 printf("Test of [cbGets] operation>>\n");
 printf("%s\n\n", cbGets(pcb, 5, getting));

 printf("Test of [cbPuts] operation>>\n");
 printf("%d\n\n", cbPuts(pcb, putting, 4));

 printf("Test of [cbGets] operation>>\n");
 printf("%s\n\n", cbGets(pcb, 5, getting));

 printf("Test of [cbGets] operation>>\n");
 printf("%s\n\n", cbGets(pcb, 5, getting));

 cbDestroy(pcb);
}

/* 佇列初始化函式，cb為佇列緩衝，size是緩衝大小 */
void cbInit(cb_t **cb, unsigned long size)
{
 *cb = (cb_t *)malloc(sizeof(cb_t));
 if ((NULL == *cb) || (NULL == cb))
 {
  printf("cbInit:Insufficient Memory!\n");
  exit(0);
 }

 (*cb)->queue = (char *)malloc(size * sizeof(char));
 if (NULL == (*cb)->queue)
 {
  printf("cbInit:Insufficient Memory!\n");
  exit(0);
 }

 memset((*cb)->queue, 0, size * sizeof(char));
 (*cb)->front = 0;
 (*cb)->rear  = 0;
}

/* 佇列加資料函式，向cb尾追加長為length的字串，存在putting中；
   當緩衝剩餘空間remain<length時，追加長為remain的字串，函式返回實際有效存放到緩衝中的字串 */
unsigned long cbPuts(cb_t *cb, char *putting, unsigned long length)
{
 unsigned long index = 0;
 if ((NULL == cb) || (NULL == putting))
 {
  printf("cbPuts:Insufficient Memory!\n");
  exit(0);
 }

 if ((cb->rear +1) % SIZE == cb->front)  // 佇列已滿
 {
  printf("Queue is full!\n");
  return 0;
 }
 else                                    // 佇列未滿
 {
  for (index = 0; index < length; index++)
  {
   if ((cb->rear + 1) % SIZE != cb->front)  // 佇列未滿，逐字元入佇列
   {
    cb->rear = (cb->rear + 1) % SIZE;
    *(cb->queue + cb->rear) = *(putting + index);
   }
   else
   {
    break;  // 佇列剩餘空間<length，佇列滿時跳出迴圈；否則，跳過該語句
   }
  }
  return index;
 }
}

/* 佇列取資料函式，在cb中讀取長度為length的字串，存於getting中；
   當佇列存放的字元數used<length時，只讀取長為used的字串，讀取字串後，佇列中相應緩衝不再使用 */
char *cbGets(cb_t *cb, unsigned long length, char *getting)
{
 unsigned long index = 0;

 if (NULL == cb)
 {
  printf("cbGets:Insufficient Memory!\n");
  exit(0);
 }

 if (cb->rear == cb->front)  // 佇列為空
 {
  printf("Queue is empty!\n");
  return NULL;
 }
 else                        // 佇列非空
 {
  for (index = 0; index < length; index++)
  {
   if (cb->rear != cb->front)  // 佇列非空，逐字元出佇列
   {
    cb->front = (cb->front + 1) % SIZE;
    *(getting + index) = *(cb->queue + cb->front);
    *(cb->queue + cb->front) = 0;  // 出佇列快取清零
   }
   else
   {
    break;  // 佇列存放位元組數<length，佇列空時跳出迴圈；否則，跳過該語句
   }
  }
  *(getting + index) = '\0';
  return getting;
 }
}

/* 佇列釋放函式，釋放cb佔用的記憶體 */
void cbDestroy(cb_t *cb)
{
 if (NULL == cb)
 {
  printf("cbDestroy:Insufficient Memory/Queue isnot Existing!\n");
  exit(0);
 }
 free(cb->queue);
 cb->queue = NULL;
 free(cb);
}