C语言实现循环队列

原创 已于 2022-04-15 14:38:48 修改 · 1.2k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #队列

于 2021-11-11 11:32:26 首次发布
本文介绍了一种通过宏定义实现的C语言通用队列，适用于多种数据类型，包括整型、指针类型和字符串。队列在满时会丢弃最早的数据，提供了初始化、去初始化、读写操作以及内存管理。代码示例展示了如何测试不同类型的队列，强调了使用后必须正确去初始化以避免内存泄漏。

背景

一般高级语言中都有直接可以使用的数据结构。c语言没有默认的实现。很多时候就根据不同是数据类型需要反复的造轮子。本文通过宏定义的方式实现了一个通用的队列实现，可以覆盖绝大部分的队列使用要求。

代码

queue.h

#ifndef __QUEUE_H_
#define __QUEUE_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef logR
#define logR(fmt,...) printf(fmt, ##__VA_ARGS__)
#endif

#ifndef logD
#define logD(fmt,...) printf("[%s@%d]" fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__)
#endif
#ifndef logI
#define logI(fmt,...) printf("[%s@%d]" fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__)
#endif
#ifndef logE
#define logE(fmt,...) printf("[%s@%d]" fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__)
#endif

typedef struct{
  void *queue;
  ssize_t l;
  ssize_t r;
  ssize_t w;
}QUEUE_HANDLE;

#define queueInit( type, handle, len ) \
  do{\
    (handle).queue = (type*)malloc(sizeof(type)*len);\
    if((handle).queue == NULL){\
      logE("malloc error");\
      break;\
    }\
    (handle).l = len;\
    (handle).r = 0;\
    (handle).w = 0;\
  }while(0)

#define queueDeinit( handle ) \
  do{\
    free((handle).queue);\
    (handle).queue = NULL;\
    (handle).r = 0;\
    (handle).w = 0;\
  }while(0)

#define CHECK_RANGE(num,max) ( (num)>0?( (num) % (max)):( ((num) + ((num)/(max)+1)*(max)) % (max) ))

#define FULL_CHECK(handle)\
  if( CHECK_RANGE((handle).w + 1,(handle).l) == CHECK_RANGE((handle).r,(handle).l))\
    (handle).r = CHECK_RANGE((handle).r+1, (handle).l) ///< 检查队列是否已经满了，满了之后则丢弃最早的一次数据

#define queueLen(handle)	CHECK_RANGE((handle).w+(handle).l - (handle).r, (handle).l) ///< 返回队列长度，w写指针，r读指针

#define queueWrite( type,handle,data)\
  ((type*)(handle).queue)[(handle).w] = data;\
  FULL_CHECK( handle );\
  (handle).w = CHECK_RANGE( (handle).w+1, (handle).l )                          ///< 向队列中写入一个数据

#define queueRead(type,handle,data) \
  data=((type*)(handle).queue)[(handle).r];\
  (handle).r = CHECK_RANGE( (handle).r+1, (handle).l )                          ///< 从队列中读出一个数据

/* 整数类型 */
#define queueInitInt(handle,len)    queueInit(int,handle,len)                ///< 初始化整形的队列
#define queueWriteInt(handle,data)  queueWrite(int,handle,data)              ///< 写入整形的数据
#define queueReadInt(handle,data)   queueRead(int,handle,data)               ///< 读取整形数据
#define queueDeinitInt(handle)      queueDeinit(handle)                  ///< 去初始化队列

/* 指针类型 */
#define FULL_CHECK_PTR(type,handle)\
  if( CHECK_RANGE((handle).w + 1,(handle).l) == CHECK_RANGE((handle).r,(handle).l)){\
    free(((type*)handle.queue)[(handle).r]);\
    ((type*)handle.queue)[(handle).r] = NULL;\
    (handle).r = CHECK_RANGE((handle).r+1, (handle).l);\
  } ///< 检查队列是否已经满了，满了之后则丢弃最早的一次数据

#define queueWritePtr( type,handle,ptr)\
  ((type*)(handle).queue)[(handle).w] = ptr;\
  FULL_CHECK_PTR( type,handle );\
  (handle).w = CHECK_RANGE( (handle).w+1, (handle).l )                          ///< 向队列中写入一个数据

#define queueDeinitPtr(type,handle)\
  for(int i=0;i<handle.l;i++){\
    if( ((type*)handle.queue)[i] != NULL ){\
    free(((type*)handle.queue)[i]);\
    ((type*)handle.queue)[i] = NULL;\
    }\
  }\
  queueDeinit(handle)                                                          ///< 去初始化字符串队列,字符串队列由于写入是使用的是strdup，所以需要将未读出的数据全部读出释放，防止内存泄露

#define FULL_CHECK_PTR_EX(type,handle,fun)\
  if( CHECK_RANGE((handle).w + 1,(handle).l) == CHECK_RANGE((handle).r,(handle).l)){\
    fun(((type*)handle.queue)[(handle).r]);\
    free(((type*)handle.queue)[(handle).r]);\
    ((type*)handle.queue)[(handle).r] = NULL;\
    (handle).r = CHECK_RANGE((handle).r+1, (handle).l);\
  } ///< 检查队列是否已经满了，满了之后则丢弃最早的一次数据

#define queueWritePtrEx( type,handle,ptr, fun)\
  ((type*)(handle).queue)[(handle).w] = ptr;\
  FULL_CHECK_PTR_EX( type,handle, fun );\
  (handle).w = CHECK_RANGE( (handle).w+1, (handle).l )                          ///< 向队列中写入一个数据

#define queueDeinitPtrEx(type,handle, fun)\
  for(int i=0;i<handle.l;i++){\
    if( ((type*)handle.queue)[i] != NULL ){\
      fun( ((type*)handle.queue)[i] );\
      free(((type*)handle.queue)[i]);\
      ((type*)handle.queue)[i] = NULL;\
    }\
  }\
  queueDeinit(handle)                                                          ///< 去初始化字符串队列,字符串队列由于写入是使用的是strdup，所以需要将未读出的数据全部读出释放，防止内存泄露

/* 字符串类型,队列不使用时一定要调用deinit释放内存，防止泄露 */
#define queueInitStr(handle,len)    queueInit(char*,handle,len)               ///< 初始化一个字符串类型的队列
#define queueDeinitStr(handle)      queueDeinitPtr(char*,handle)              ///< 去初始化字符串队列,字符串队列由于写入是使用的是strdup，所以需要将未读出的数据全部读出释放，防止内存泄露

#define queueWriteStr(handle,str)   queueWritePtr(char*, handle, strdup(str)) ///< 向队列中写入一个字符串,使用strdup拷贝字符串到队列中
#define queueReadStr(handle,strPtr) queueRead(char*,handle,strPtr)            ///< 从队列中读出一个字符串，使用完毕之后需要释放内存

#endif

queue2.c

#include "queue2.h"
#include <malloc.h>

#if 0   // 内存分配调试
extern void *__libc_malloc(size_t size);
extern void *__libc_free(void *ptr);

int malloc_hook_active = 1;
int free_hook_active = 1;

void* my_malloc_hook (size_t size, void *caller)
{
  void *result;

  // deactivate hooks for logging
  malloc_hook_active = 0;

  result = malloc(size);

  // do logging
  printf("+malloc(%ld) %p\n", size, result);

  // reactivate hooks
  malloc_hook_active = 1;

  return result;
}

void my_free_hook(void *ptr, void *caller)
{

  // deactivate hooks for logging
  free_hook_active = 0;

  free(ptr);

  // do logging
  printf("-free() %p\n", ptr);

  // reactivate hooks
  free_hook_active = 1;

}

void* malloc (size_t size)
{
  void *caller = __builtin_return_address(0);
  if (malloc_hook_active)
    return my_malloc_hook(size, caller);
  return __libc_malloc(size);
}

void free(void *ptr)
{
  void *caller = __builtin_return_address(0);
  if (free_hook_active)
    my_free_hook(ptr, caller);
  else
    __libc_free(ptr);
}
#endif

typedef struct{
  char buff[8];
  int  len;
}USER_STRUCT;

typedef struct{
  char *buff;
  int  len;
}USER_STRUCT_EX;

/*
 * @brief 打印整形队列数组中的所有的数据，队列的中数据以绿色打印
 * */
void printQueueInt(QUEUE_HANDLE handle)
{
#define DEFAULT   "\033[0m"
#define GREEN     "\033[0;32m\033[1m"
#define TEXT_GREEN(s)   GREEN s "\033[0m"

  for(int i=0; i< handle.l; i++){
    if(
       ( handle.w>handle.r && handle.r <= i && i< handle.w && handle.r != handle.w ) ||
       ( handle.w<handle.r && ( i<handle.w || handle.r <= i ) && handle.r != handle.w )
      ){
      logR(TEXT_GREEN("%2d "),((int*)handle.queue)[i]);
    }else{
      logR("%2d ",((int*)handle.queue)[i]);
    }
  }
  logR("\tr:%2ld, w:%2ld\n", handle.r, handle.w);
}

/*
 * @brief 打印字符队列数组中的所有的数据，队列的中数据以绿色打印
 * */
void printQueueStr(QUEUE_HANDLE handle)
{
#define DEFAULT   "\033[0m"
#define GREEN     "\033[0;32m\033[1m"
#define TEXT_GREEN(s)   GREEN s "\033[0m"

  for(int i=0; i< handle.l; i++){
    if(
       ( handle.w>handle.r && handle.r <= i && i< handle.w && handle.r != handle.w ) ||
       ( handle.w<handle.r && ( i<handle.w || handle.r <= i ) && handle.r != handle.w )
      ){
      logR(TEXT_GREEN("'%s' "),((char**)handle.queue)[i]);
    }else{
      logR("'%s' ",((char**)handle.queue)[i]);
    }
  }
  logR("\tr:%2ld, w:%2ld\n", handle.r, handle.w);
}

/*
 * @brief 打印字符队列数组中的所有的数据，队列的中数据以绿色打印
 * */
void printQueuePtr(QUEUE_HANDLE handle)
{
#define DEFAULT   "\033[0m"
#define GREEN     "\033[0;32m\033[1m"
#define TEXT_GREEN(s)   GREEN s "\033[0m"

  for(int i=0; i< handle.l; i++){
    if(
       ( handle.w>handle.r && handle.r <= i && i< handle.w && handle.r != handle.w ) ||
       ( handle.w<handle.r && ( i<handle.w || handle.r <= i ) && handle.r != handle.w )
      ){
      logR(TEXT_GREEN("'%s' "), ((USER_STRUCT**)handle.queue)[i]->buff );
    }else{
      logR("'%s' ", ((USER_STRUCT**)handle.queue)[i]->buff );
    }
  }
  logR("\tr:%2ld, w:%2ld\n", handle.r, handle.w);
}

/*
 * @brief 打印字符队列数组中的所有的数据，队列的中数据以绿色打印
 * */
void printQueuePtrEx(QUEUE_HANDLE handle)
{
#define DEFAULT   "\033[0m"
#define GREEN     "\033[0;32m\033[1m"
#define TEXT_GREEN(s)   GREEN s "\033[0m"

  for(int i=0; i< handle.l; i++){
    if(
       ( handle.w>handle.r && handle.r <= i && i< handle.w && handle.r != handle.w ) ||
       ( handle.w<handle.r && ( i<handle.w || handle.r <= i ) && handle.r != handle.w )
      ){
      logR(TEXT_GREEN("'%s' "), ((USER_STRUCT_EX**)handle.queue)[i]->buff );
    }else{
      if( ((USER_STRUCT_EX**)handle.queue)[i] != NULL )
        logR("'%s' ", ((USER_STRUCT_EX**)handle.queue)[i]->buff );
      else
        logR("(null) ");
    }
  }
  logR("\tr:%2ld, w:%2ld\n", handle.r, handle.w);
}

int main_int()
{
  int data=0;
  logD("空队列：");
  QUEUE_HANDLE test_int;
  queueInitInt(test_int,8);

  logD("\n");

  for(int i=0; i<12; i++){
    data = rand()%100;
    logD("插入数据：%d", data);
    queueWriteInt(test_int, data);
    printQueueInt(test_int);
  }

  logD("\n");

  while(queueLen(test_int)>0){
    queueReadInt(test_int, data);
    logD("读出数据：%d", data);
    printQueueInt(test_int);
  }
  queueDeinitInt(test_int);
  return 0;
}

int main_str()
{
  logD("空队列：");
  QUEUE_HANDLE test_str;
  queueInitStr(test_str,8);

  logD("\n");

  for(int i=0; i<12; i++){
    int data=0;
    char buff[5] = {0};
    data = rand()%100;
    sprintf(buff,"%2d",data);
    logD("插入数据：'%s'", buff);
    queueWriteStr(test_str, buff);
    printQueueStr(test_str);
  }

  logR("\n");

  while(queueLen(test_str)>0){
    char *str = NULL;
    queueReadStr(test_str, str);
    logD("读出数据：'%s'", str);
    printQueueStr(test_str);
  }
  logD("deinit queue");
  queueDeinitStr(test_str);
  return 0;
}

int main_user()
{
  logD("空队列：");
  QUEUE_HANDLE test_user;
  queueInit( USER_STRUCT*,test_user, 8 );

  logD("\n");

  for(int i=0; i<12; i++){
    int data=0;
    USER_STRUCT *user = (USER_STRUCT*)malloc(sizeof(USER_STRUCT));
    data = rand()%100;
    sprintf(user->buff,"%2d",data);
    user->len = strlen(user->buff);
    logD("插入数据：'%s'", user->buff);
    queueWritePtr( USER_STRUCT*,test_user, user);
    printQueuePtr(test_user);
  }

  logR("\n");

  while(queueLen(test_user)>0){
    USER_STRUCT *user = NULL;
    queueRead( USER_STRUCT*, test_user, user);
    logD("读出数据：%d:'%s'", user->len, user->buff);
    printQueuePtr(test_user);
  }
  logD("deinit queue");
  queueDeinitPtr( USER_STRUCT*, test_user);
  return 0;
}

void del_user_struct_ex(USER_STRUCT_EX *user)
{
  if( user->buff != NULL ){
    free( user->buff );
    user->buff = NULL;
  }
}

int main_user_ex()
{
  logD("空队列：");
  QUEUE_HANDLE  test_user_ex;
  queueInit( USER_STRUCT_EX*,test_user_ex, 8 );

  logD("\n");

  for(int i=0; i<12; i++){
    int data=0;
    USER_STRUCT_EX *user = (USER_STRUCT_EX*)malloc(sizeof(USER_STRUCT_EX));
    data = rand()%100;
    char buff[8];
    sprintf(buff,"%2d",data);
    user->buff = strdup(buff);
    user->len = strlen(user->buff);
    logD("插入数据：'%s'", user->buff);
    queueWritePtrEx( USER_STRUCT_EX*,test_user_ex, user, del_user_struct_ex);
    logD();
    printQueuePtrEx(test_user_ex);
  }

  logR("\n");

  while(queueLen(test_user_ex)>0){
    USER_STRUCT_EX *user = NULL;
    queueRead( USER_STRUCT_EX*, test_user_ex, user);
    logD("读出数据：%d:'%s'", user->len, user->buff);
    printQueuePtrEx(test_user_ex);
  }
  logD("deinit queue");
  queueDeinitPtrEx( USER_STRUCT_EX*, test_user_ex, del_user_struct_ex);
  return 0;
}

void user_help(char *app)
{
  logE("%s [0/1/2/3]", app);
  logE("%s 0 test int queue", app);
  logE("%s 1 test string queue", app);
  logE("%s 2 test custom type queue", app);
  logE("%s 3 test custom extension type queue", app);
}

int main(int argc, char *argv[])
{
  if(argc != 2){
    user_help( argv[0] );
    return 0;
  }
  switch( atoi(argv[1]) ){
  case 0:
    return main_int();
  case 1:
    return main_str();
  case 2:
    return main_user();
  case 3:
    return main_user_ex();
  default:
    user_help( argv[0] );
    return 0;
  }
}

说明

通过输入不同的参数可以执行不同类型的队列测试

注意

当队列不使用时一定要执行与初始化想匹配的去初始化，否则会导致内存溢出。文中注释部分有一种内存溢出查找的代码。
具体使用方法或者其他调试方法可以参见https://blog.youkuaiyun.com/cooper1024/article/details/124177568?spm=1001.2014.3001.5501

cooper1024
关注
C语言程序实现模拟图形打印机
weixin_43773462的博客
06-10 994
基于C语言程序实现模拟图形打印机 头文件和全局变量： #include<stdio.h> #include<stdlib.h> #include<math.h> #define N 10 #define X 20 //圆心x坐标 #define Y 20 //圆心Y坐标 int number = 0; 用“*”打印出正方形 void square(int number) { int x, y; for (x = 0; x < number;
初始化循环队列、添加元素、打印循环队列
heibusi的博客
05-11 1676
初始化循环队列、添加元素、打印循环队列 学习队列重要的是理解如何判空、如何判断队满以及如何得出循环队列的元素个数。还应该知道为什么11个元素容量的循环队列一般只放10个元素。这些如果能够理解了，增删改查就都明白了。请看代码，我已将重要的东西注释出来了哦！！！！ #include <stdio.h> #include <iostream> #define maxsize 10 using namespace std; //利用受限顺序表来表示队列 typedef struct queu
循环队列出入打印C++
m0_62591999的博客
08-22 655
循环队列的操作
Linux之旅-第一个内核打印信息
dream的专栏
04-30 724
1、编译环境： 根据Tiny4412用户手册.pdf中的3.2节完成开发环境的配置： 2、新增内核日志打印宏定义 #define LOGE(fmt, ...) printk(KERN_ERR "[E]"LOG_TAG"[%s][%s][%d]"fmt, __FILE__, __func__, __LINE__, ##__VA_ARGS__) #define LOGD(fmt, ...) printk(KERN_DEBUG "[D]"LOG_TAG"[%s][%s][%d]"fmt, _.
循环队列C语言实现
Helpsen的博客
02-08 663
循环队列C语言实现 特性： 先进先出(First In First Out=FIFO)，取数从队列的开头取，存储从队列尾部存。第一个元素又称首元素,最后一个元素又称尾元素。 Linux系统三大队列： 消息队列：进程间通信的一种手段。 工作队列：延后执行的一种手段。 等待队列：随时随地让进程休眠并且让进程随时随地被唤醒。 /*循环队列*/ #include <stdio.h> #include <stdlib.h> /*声明描述队列属性的结构体*/ typedef struc
C语言数据结构算法队列之循环队列的基本操作（创建队列，入队，出队，求长度，取队头，判断队列满空，打印队列）
weixin_63381305的博客
12-26 1211
【代码】C语言数据结构算法队列之循环队列的基本操作（创建队列，入队，出队，求长度，取队头，判断队列满空，打印队列）
精选资源
C语言实现循环队列代码
08-20
本文将详细介绍如何用C语言实现循环队列，并探讨其核心功能——入队、出队和打印队列元素。 首先，我们需要定义一个队列结构体，它通常包含队列的容量、当前队头和队尾索引，以及用于存储元素的数组。例如： ```c ...
数据结构-循环队列-C语言实现循环队列-数据结构学习
05-27
C语言实现的数据结构中的循环队列 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及测试用的main.c文件 用于C语言以及数据结构的学习 循环队列的.c和.h文件实现了以下功能： 创建循环队列 入队列...
下面是打印遍历循环队列的独创方法
mzy1711231996的博客
11-14 908
下面是打印遍历循环队列的独创方法 // 遍历 public void list() { //计算出有效元素个数 int count = getCount(); if (count == 0) { System.out.println("没有元素"); return; } int c=0;//次数 int i=front;//得到头元素所在位置 for (int j = c; j < count; j++) { System.out.print(arr[
C语言数据结构———循环队列(数组实形式用宏定义方式实现)
RaphaelCeo的博客
09-18 755
C语言数据结构———循环队列(数组实形式用宏定义方式实现) 文章目录C语言数据结构———循环队列(数组实形式用宏定义方式实现)意图目的一、数据类型定义二、队列结构体定义三、操作队列的函数四、简单测试 意图目的 使用宏定义方式来实现循环队列的效率比较高。 一、数据类型定义 typedef unsigned char u8; typedef unsigned short int u16; typedef unsigned int .
循环队列打印Fibonacci
11-13
采用循环队列打印Fibonacci。。。 循环队列数据结构一个很经典的算法
循环队列初始化、进队出队、打印输出
03-17
实现循环队列初始化、进队出队、打印输出所有队列元素、获取队头元素，dos窗口输出。一般队列可在此基础上修改即可！
C语言实现循环队列，入队，出队，遍历打印
天下第一干饭王的博客
05-16 2213
【代码】C语言实现循环队列，入队，出队，遍历打印。
C语言基础篇（四）——循环结构
defineNULL的博客
12-17 482
C语言基础篇（四）——循环结构一.for语句1.模板for(表达式1;表达式二;表达式3) { 语句块 }为了能大家能充分理解for循环语句的执行顺序，我们编写一段代码尝试下：#include<stdio.h>int main() { int i; for (i = 0,printf("表达式1\n");printf("表达式2\n"), i < 3; i++,printf(
循环队列的 创建、入队、出队、打印
最新发布
zhangbingbingya的博客
10-25 381
printf("出队元素为：%d\n", e);//设置e用来接收出队的元素的值。//队列元素出队 并且用e来接收出队的元素的值。//插入值为x的元素。
c语言打印队列的程序,队列的基本操作（C语言版）：进队，出队，输出
weixin_42516668的博客
05-17 1329
#include#includetypedef struct queue{int data;struct queue *link;}QUEUE;void EnQueue(QUEUE **head,QUEUE**tail,int x){//从队尾tail进队QUEUE *p;p=(QUEUE*)malloc(sizeof(QUEUE));p->data=x;p->link=NULL;if...
C语言（C++）数据结构循环队列基本操作和功能验证
qq_59205716的博客
11-03 361
数据结构循环队列的基本功能及验证
循环队列
qq_39475906的博客
05-09 1852
循环队列 特性：先进先出，浪费一个数据单元，用来判断是否为满 原理 代码实现 class QueueLink{ int elem[]; /** * 队头 */ int front; /** * 队尾 */ int rear; /** * 当前循环内部有效循环个数 */ ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值