相对通用的C语言队列

最新推荐文章于 2024-07-11 22:07:49 发布
最新推荐文章于 2024-07-11 22:07:49 发布
阅读量283 收藏
点赞数
文章标签： 队列 指针 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36718417/article/details/116607314
版权

心血来潮加上上班摸鱼，写了个队列，感觉还是比较通用的吧，先看头文件:

#ifndef __QUEUE_H__
#define __QUEUE_H__

#include <stdint.h>

struct queue_handle_t
{
    //队列的名字
    char name[32];
    //创建内存地址的起始位置
    void *start_addr;
    //末尾地址
    void *finish_addr;
    //指向队首成员
    void *head_ptr;
    //指向队尾成员
    void *tail_ptr;
    //队列中最大成员数量
    uint32_t max_member;
    //队列中单个成员的尺寸
    uint32_t member_size;
    //当前成员数量
    uint32_t member_num;
    //是否被初始化
    uint16_t is_init;
    uint16_t is_creat;
    //内部用到的函数
    int (*internal_print)(const char *, ...);
    void *(*internal_malloc)(size_t);
    void (*internal_free)(void *);
};

/*
 * 初始化队列句柄
 * @param:
 *      handle:队列句柄
 * @note:
 *      在创建队列 creat_queue() 前调用
 * @return:
 *      0是成功
 */
int init_queue(struct queue_handle_t *handle,
               void *(*malloc_func)(size_t),
               void (*free_func)(void *),
               int (*log_func)(const char *format, ...));

/*
 * 创建队列
 * @param:
 *      handle:队列句柄
 *      name:队列的名字
 *      max_member:队列元素个数的最大数量
 *      size:每个元素的尺寸
 * @return:
 *      0是成功
 */
int creat_queue(struct queue_handle_t *handle, const char *name, const uint32_t max_member, const uint32_t size);

/*
 *删除队列
 *@param:
 *  handle:队列句柄
 */
int delete_queue(struct queue_handle_t *handle);

/*
 * 入队
 * @param:
 *      handle:队列句柄
 *      data_ptr:加入的元素
 * @return:
 *      0是成功
 */
int entern_queue(struct queue_handle_t *handle, const void *data_ptr);
/*
 * 出队
 * @param:
 *      handle:队列句柄
 *      data_ptr:加入的元素
 * @return:
 *      0是成功
 * @note:
 *      会删除队首元素
 */
int read_queue(struct queue_handle_t *handle, void *data_ptr);

/*
 * 出队
 * @param:
 *      handle:队列句柄
 *      data_ptr:加入的元素
 * @return:
 *      0是成功
 * @note:
 *      不会删除队首元素
 */
int peek_queue(struct queue_handle_t *handle, void *data_ptr);

/*
 * 读取队尾的元素
 * @param:
 *      handle:队列句柄
 *      data_ptr:加入的元素
 * @return:
 *      0是成功
 * @note:
 */
int read_tail_queue(struct queue_handle_t *handle, void *data_ptr);

#endif

 

相信有的帅批看完头文件已经知道我是咋写的了，源文件:

//缺点:一个队列里的每个元素只能是大小一样的,在队列初始时就决定了队列的大小
#include "queue.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//提高这个值可以稍微提高一些安全性(避免空指针引用啥的)
#define QUEUE_SAFE_LEVEL 0

#define QUEUE_INIT_FLG 0XF1a5
#define QUEUE_CREAT_FLG 0XF1a5
#define QUEUE_LOG(fmt,arg...) if(handle->internal_print){handle->internal_print(fmt, ##arg);}

static inline int check_handle(struct queue_handle_t *handle)
{
#if QUEUE_SAFE_LEVEL >= 1
    if (handle == NULL)
    {
        return -1;
    }
    if (handle->is_init != QUEUE_INIT_FLG)
    {
        return -2;
    }
    if (handle->internal_malloc == NULL || handle->internal_free == NULL)
    {
        return -3;
    }
#endif
    return 0;
}


/*
 * 初始化队列句柄
 * @param:
 *      handle:队列句柄
 * @note:
 *      在创建队列时 creat_queue() 前调用
 * @return:
 *      0是成功
 */
int init_queue(struct queue_handle_t *handle,
               void *(*malloc_func)(size_t),
               void (*free_func)(void *),
               int (*log_func)(const char *format, ...))
{
    if (handle == NULL || malloc_func == NULL || free_func == NULL)
    {
        return -1;
    }
    memset(handle, 0, sizeof(struct queue_handle_t));
    handle->internal_malloc = malloc_func;
    handle->internal_free = free_func;
    handle->internal_print = log_func;
    handle->is_init = QUEUE_INIT_FLG;
    return 0;
}

/*
 * 创建队列
 * @param:
 *      handle:队列句柄
 *      name:队列的名字
 *      max_member:队列元素个数的最大数量
 *      size:每个元素的尺寸
 * @return:
 *      0是成功
 */
int creat_queue(struct queue_handle_t *handle, const char *name, const uint32_t max_member, const uint32_t size)
{
    void *p_start;
    uint32_t sum_size = max_member * size;
    if (check_handle(handle))
    {
        return -1;
    }
    //判断队列是否被创建
    if (handle->is_creat)
    {
        QUEUE_LOG("Warring:%s:%d:Queue %s May be Created Or Hnadle Not Init,New Queue Will Not be Created\n", __FUNCTION__, __LINE__, handle->name);
        return -1;
    }
    //队列名字是否合法
    if (strlen(name) <= 0 || strlen(name) >= 32)
    {
        QUEUE_LOG("Error:%s:%d:Queue Name Len Must More Than 0 But Less Than 32\n", __FUNCTION__, __LINE__, handle->name);
        return -1;
    }
    p_start = handle->internal_malloc(sum_size);
    if (p_start == NULL)
    {
        QUEUE_LOG("Error:%s:%d:Queue Creat Fail\n", __FUNCTION__, __LINE__);
        handle->start_addr = NULL;
        return -1;
    }
    handle->start_addr = p_start;
    handle->head_ptr = p_start;
    handle->tail_ptr = p_start;
    handle->max_member = max_member;
    handle->member_size = size;
    handle->member_num = 0;
    handle->finish_addr = (uint8_t *)p_start + sum_size;
    handle->is_creat = QUEUE_CREAT_FLG;
    strcpy(handle->name, name);
    memset(handle->start_addr, 0, sum_size);
    return 0;
}

/*
 *删除队列
 *@param:
 *  handle:队列句柄
 */
int delete_queue(struct queue_handle_t *handle)
{
    if (check_handle(handle) || handle->start_addr == NULL)
    {
        QUEUE_LOG("Error:%s:%d:Queue Delete Fail\n", __FUNCTION__, __LINE__);
        return -1;
    }
    handle->internal_free(handle->start_addr);
    memset(handle, 0, sizeof(struct queue_handle_t));
    handle->start_addr = NULL;
    handle->finish_addr = NULL;
    return 0;
}

/*
 * 入队
 * @param:
 *      handle:队列句柄
 *      data_ptr:加入的元素
 *      size:加入元素的大小
 * @return:
 *      0是成功
 */
int entern_queue(struct queue_handle_t *handle, const void *data_ptr)
{
    if (check_handle(handle))
    {
        return -1;
    }
    //判断队列是否被创建
    if (handle->start_addr == NULL)
    {
        QUEUE_LOG("Error:%s:%d:Queue Enter Fail,Maybe Not Creat\n", __FUNCTION__, __LINE__);
        return -1;
    }
    //判断元素数量是否达到上限
    if (handle->member_num >= handle->max_member)
    {
        QUEUE_LOG("Error:%s:%d:Queue Enter Fail,Member Too Much\n", __FUNCTION__, __LINE__);
        return -1;
    }
    //如果队尾指针已经来到内存边界,那么将尾指针指回开头
    if (handle->tail_ptr >= handle->finish_addr)
    {
        handle->tail_ptr = handle->start_addr;
    }
    memcpy(handle->tail_ptr, data_ptr, handle->member_size);
    handle->tail_ptr = (uint8_t *)handle->tail_ptr + handle->member_size;
    handle->member_num++;
    return 0;
}

/*
 * 出队
 * @param:
 *      handle:队列句柄
 *      data_ptr:加入的元素
 *      size:加入元素的大小
 * @return:
 *      0是成功
 * @note:
 *      会删除队首元素
 */
int read_queue(struct queue_handle_t *handle, void *data_ptr)
{
   if (check_handle(handle))
    {
        return -1;
    }
    //判断元素数量是否大于0
    if (handle->member_num <= 0)
    {
        QUEUE_LOG("Error:%s:%d:Queue Read Fail,Member Too Less\n", __FUNCTION__, __LINE__);
        return -1;
    }
    //如果队首指针已经来到内存边界,那么将首指针指回开头
    if (handle->head_ptr >= handle->finish_addr)
    {
        handle->head_ptr = handle->start_addr;
    }
    memcpy(data_ptr, handle->head_ptr, handle->member_size);
    handle->head_ptr = (uint8_t*)handle->head_ptr + handle->member_size;
    handle->member_num--;
    return 0;
}


/*
 * 出队
 * @param:
 *      handle:队列句柄
 *      data_ptr:加入的元素
 *      size:加入元素的大小
 * @return:
 *      0是成功
 * @note:
 *      不会删除队首元素
 */
int peek_queue(struct queue_handle_t *handle, void *data_ptr)
{
    if (check_handle(handle))
    {
        return -1;
    }
    //判断元素数量是否大于0
    if (handle->member_num <= 0)
    {
        QUEUE_LOG("Error:%s:%d:Queue Read Fail,Member Too Less\n", __FUNCTION__, __LINE__);
        return -1;
    }
    //如果队首指针已经来到内存边界,那么将首指针指回开头
    if (handle->head_ptr >= handle->finish_addr)
    {
        handle->head_ptr = handle->start_addr;
    }
    memcpy(data_ptr, handle->head_ptr, handle->member_size);
    return 0;
}

/*
 * 读取队尾的元素
 * @param:
 *      handle:队列句柄
 *      data_ptr:加入的元素
 *      size:加入元素的大小
 * @return:
 *      0是成功
 * @note:
 */
int read_tail_queue(struct queue_handle_t *handle, void *data_ptr)
{
    if (check_handle(handle))
    {
        return -1;
    }
    //判断元素数量是否大于0
    if (handle->member_num <= 0)
    {
        QUEUE_LOG("Error:%s:%d:Queue Read Fail,Member Too Less\n", __FUNCTION__, __LINE__);
        return -1;
    }
    //指向最后一个元素
    if (handle->tail_ptr <= handle->start_addr)
    {
        handle->tail_ptr = (uint8_t *)handle->finish_addr - handle->member_size;
    }
    else
    {
        handle->tail_ptr = (uint8_t*)handle->tail_ptr - handle->member_size;
    }
    memcpy(data_ptr, handle->tail_ptr, handle->member_size);
    handle->member_num--;
    return 0;
}


#if 0

struct a_t
{
    uint64_t v1;
    char v2;
    uint64_t v3;
} a ,aa;

int main()
{
    struct queue_handle_t h1;
    uint16_t arr[5] = {1, 2, 3};
    uint16_t read;
    double count = 100000;
    init_queue(&h1,malloc,free,printf);
    creat_queue(&h1, "test", 100, sizeof(a));

    printf("%ld\n", sizeof(struct a_t));

    for (double i = 0; i < count; i++)
    {
        a.v3 = i;
        entern_queue(&h1, &a);
        entern_queue(&h1, &a);
        entern_queue(&h1, &a);
        entern_queue(&h1, &a);
        read_queue(&h1, &aa);
        read_tail_queue(&h1, &aa);
        read_tail_queue(&h1, &aa);
        read_queue(&h1, &aa);
        printf("%.10f%%\r", 100 * (i / count));
        fflush(stdout);
    }
    printf("\n%d\n", aa.v3);
    return 0;
}

#endif


#undef QUEUE_INIT_FLG
#undef QUEUE_CREAT_FLG
#undef QUEUE_LOG

感觉单片机上也可以跑，什么，没有malloc？没事，用全局变量就可以了比如下面这样:

static char rnm_tq[100];

void *rnm_tq_malloc(size_t n)
{
    return &rnm_tq[0];
}

反正也是个静态队列。

哦，对了，如果涉及多线程的话，该还是得自己加锁的

醉梦千秋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
优先队列C语言实现
XianBT的专栏
08-03 4807
优先队列利用堆实现，堆的实现在前面已经说过了，优先队列的一个重要的操作是： 1.  heap_max  O(1)   2. heap_extract_max  O(lgn) 3. heap_increase_key  O(lgn) 4, heap_insert  O(lgn) 下面是C语言实现 #define MIN -100000 int heap_max(struct heap
队列的C语言实现
i晨i曦520
09-27 494
# include <stdio.h> # include <malloc.h> # include <stdbool.h> typedef struct queue{ int *start; int first; int last; }Q,*QUEUE; void init(QUEUE q){ //the length of queue is
FreeRTOS 教程指南 学习笔记 第四章 队列管理
gjhave的博客
08-19 808
如何创建一个队列。队列如何管理其包含的数据。如何将数据发送到队列。如何从队列中接收数据。在队列上阻塞的含义。如何在多个队列上阻塞。如何覆盖队列中的数据。如何清除一个队列。写入队列和阅读队列时任务优先级的影响。本章中只介绍了任务到任务的通信。第6章介绍了任务中断和中断到任务通信。
FreeRTOS api库函数之Queues（队列）
qq_43400642的博客
01-31 2385
xQueueCreate QueueHandle_t xQueueCreate（UBaseType_t uxQueueLength，UBaseType_t uxItemSize）; 创建一个新队列并返回一个句柄，通过该句柄可以引用该队列。在FreeRTOSConfig.h中，configSUPPORT_DYNAMIC_ALLOCATION必须设置为1，或者保留未定义（在这种情况下默认为1），以使此...
【Freertos基础入门】队列(queue)的使用
m0_62599305的博客
08-19 1683
FreeRTOS是一个广泛使用的开源实时操作系统（RTOS），它提供了丰富的功能和特性，使嵌入式系统的开发更加简单和高效。队列是FreeRTOS中常用的一种通信机制，它用于在任务之间传递数据。队列是FreeRTOS中一种有用的通信机制，可用于在任务之间传递数据。通过使用队列，我们可以实现任务之间的数据共享和同步。在使用队列时，需要注意队列的深度和每个数据项的大小，并选择适当的阻塞等待时间以避免资源争用和任务饥饿等问题。
【FreeRTOS】详细讲解FreeRTOS中消息队列并通过示例讲述其用法
黑心萝卜三条杠的博客
01-31 9473
本文详细地讲解了FreeRTOS消息队列的相关函数及其用法，使用用示例讲解各个函数实际用法以及实际使用过程中碰到的问题。
Queue的三种数据传递
qq56hm的博客
08-19 705
队列是任务间通信的主要形式。它们可以用于在任务之间、中断和任务之间发送消息。在大多数情况下，它们被用作线程安全的FIFO (First In First Out)缓冲区，新数据被发送到队列的后面，尽管数据也可以发送到队列的前面。一个sendTask向队列发送数据，一个recTask从队列中接收数据。
util_tools:通用工具接口源码-c语言
03-23
下面我们将深入探讨这些通用工具接口在C语言中的实现及其重要性。 首先，我们来关注"系统开源"这个标签。这意味着`util_tools`项目是开放源代码的，允许开发者查看、学习和修改源码。开源软件的好处在于透明度和...
二叉树 搜索 遍历 c语言
04-17
同时，为了提高代码的可读性和复用性，可以定义通用的遍历函数，接受一个回调函数作为参数，该回调函数在访问每个节点时被调用，处理节点的具体逻辑。 总的来说，理解和掌握二叉树的搜索及遍历方法对于提升C语言...
数据结构C语言版ppt课件
12-01
C语言中的栈和队列可以通过数组或链表实现，理解和掌握这些数据结构对于理解和优化程序流程至关重要。 第04章（未提供） 虽然文件列表中没有这一章，但在完整的课程中，这一章可能会涵盖其他基本数据结构，如集合、...
如何实现单片机C语言的模块化编程.rar_togetherw2k_单片机_如何实现单片机C语言的模块化编程
09-22
1. **模块化概念**：模块化编程是指将一个大型的、复杂的程序拆分成若干个功能单一、相对独立的模块。每个模块有明确的职责，便于理解和测试。 2. **C语言基础**：C语言是一种结构化的编程语言，支持函数作为基本的...
C语言嵌入式系统编程修炼之道
03-21
3. **编译与链接**：在嵌入式环境中，编译和链接过程与通用计算机有所不同。理解交叉编译，即在一种环境下编写代码，而在另一种环境下运行，是嵌入式开发的重要部分。 4. **内存管理**：嵌入式系统往往资源有限，...
003 FreeRTOS 队列
APP_xinyonghu_li的博客
03-07 393
FreeRTOS 队列
二进制信号量和计数信号量源码分析
weixin_72238916的博客
02-04 349
二进制信号量和计数信号量源码分析
FreeRTOS Queue
波仔的博客
04-15 409
变量定义 typedef void *QueueHandle_t; // Type by which queues are referenced. typedef void *QueueSetHandle_t; // Type by which queue sets are referenced. typedef void *QueueSetMemberHandle_t; /* For internal use only. */ #define queueSEND_TO_BACK ((BaseTy
【FreeRTOS】9.STM32移植-队列
qq_44078824的博客
08-23 296
定义： 队列是任务与任务、中断与任务直接通信二准备的。队列用于消息传递，又叫做消息队列。需要交流的数据保存在队列中，叫做队列项目。队列所能保存的队列项数量叫队列长度。 typedef struct QueueDefinition { int8_t *pcHead; //头 int8_t *pcTail; //尾 int8_t *pcWriteTo; //下一个空闲区域 union //联合体 { int8_t *pcReadFrom; //当用作队列指向
4.3 FreeRTOS----队列的应用
IoT的搬运工！！！
08-27 418
xQueueCreate（）API函数         在使用队列之前必须明确创建一个队列。         队列由句柄引用，它们是QueueHandle_t类型的变量。 xQueueCreate() API函数创建一个队列，并返回一个引用其创建的队列的QueueHandle_t。         FreeRTOS V9.0.0还包括xQueueCreateStatic（）函数，它在编译时分
Free RTOS-9消息队列6队列集合
fanzhipeng7000的博客
06-30 62
/ 创建队列,返回队列的句柄。// 创建队列,返回队列的句柄。// 在队列中发布项目。1, // 任务优先级。4096, // 分配内存。1, // 任务优先级。4096, // 分配内存。(void *)xQueueSet, // 传参数。vTaskCode, // 任务函数。4096, // 分配内存。(void *)QHandle1, // 传参数。
数据结构—链式二叉树-C语言
最新发布
h_number_1的博客
07-11 1054
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值