【C语言封装设计】之队列例程

已于 2023-04-10 22:06:01 修改
阅读量129 收藏
点赞数
分类专栏： 编程语言 文章标签： c语言 c++ 算法
于 2023-04-10 21:32:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46211259/article/details/130070291
版权

目录

一、基类

二、继承

 注：例程摘自《C嵌入式编程设计模式》

一、基类

/*queue.h =========================================================*/
#ifndef _QUEUE_H
#define _QUEUE_H

#define QUEUE_SIZE 10

/* class queue */
typedef struct Queue Queue;
struct Queue {
    int buffer[QUEUE_SIZE];    /* where the data things are */
    int head;
    int size;
    int tail;
    int (*isFull)(Queue *const me);
    int (*isEmpty)(Queue *const me);
    int (*getSize)(Queue *const me);
    void (*insert)(Queue *const me, int k);
    int (*remove)(Queue *const me);
};

/*constructors and destructors: */
void Queue_init(Queue *const me, int (*isFullfunction)(Queue *const me),
                int (*isEmptyfunction)(Queue *const me),
                int (*getSizefunction)Queue *const me,
                int (*insertfunction)(Queue *const me, int k),
                int (*removefunction)(Queue *const me));

void Queue_Cleanup(Queue *const me);

/* operations */
int Queue_isFull(Queue *const me);
int Queue_isEmpty(Queue *const me);
int Queue_getSize(Queue *const me);
void Queue_insert(Queue *const me, int k);
int Queue_remove(Queue *const me);

Queue *Queue_Create(void);
void Queue_Destroy(Queue *const me);

#endif /* _QUEUE_H */

/*queue.c ===================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

void Queue_init(Queue *const me, int (*isFullfunction)(Queue *const me),
                int (*isEmptyfunction)(Queue *const me),
                int (*getSizefunction)Queue *const me,
                int (*insertfunction)(Queue *const me, int k),
                int (*removefunction)(Queue *const me))
{
    /* initialize attributes */
    me->head = 0;
    me->size = 0;
    me->tail = 0;
    me->tail = 0;
    /* initialize memberfunction pointers */
    me->isFull = isFullfunction;
    me->isEmpty = isEmptyfunction;
    me->getSize = getSizefunction;
    me->insert = insertfunction;
    me->remove = removefunction;
}

void Queue_Cleanup(Queue *const me)
{
    
}

/* operations */
int Queue_isFull(Queue *const me)
{
    return (me->head + 1) %QUEUE_SIZWE == me->tail;
}

int Queue_isEmpty(Queue *const me)
{
    return (me->head == me->tail);
}

int Queue_getSize(Queue *const me)
{
    return me->size;
}

void Queue_insert(Queue *const me, int k)
{
    if(!me->ifFull(me)) {
        me->buffer[me->head] = k;
        me->head = (me->head + 1) %QUEUE_SIZE;
        ++me->size;
    }
}
int Queue_remove(Queue *const me)
{
    int value = -9999; //sentinel value
    if(!me->isEmpty(me)) {
        value = me->buffer[me->tail];
        me->tail = (me->tail + 1)%QUEUE_SIZE;
        ++me->size;
    }
    return value;
}

Queue *Queue_Create(void)
{
    Queue *me = (Queue *)malloc(sizeof(Queue));
    if (me != NULL) {
        Queue_Init(me, Queue_isFull, Queue_isEmpty, Queue_getSize,
        Queue_insert, Queue_remove);
    }
    return me;
}
void Queue_Destroy(Queue *const me)
{
    if(me != NULL) {
        Queue_Cleanup(me);
    }
    
    free(me);
}

/*main.c =============================================================*/
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

int main(void) 
{
    int j, k, h, t;
    
    /*  test normal queue */
    Queue *myQ;
    myQ = Queue_Create();
    k = 1000;
    
    for (j = 0; j < QUEUE_SIZE; j++) {
        h = myQ->head;
        myQ->insert(myQ, k);
        printf("inserting %d at position %d, size = %d\n", k--, h, myQ->getSize(myQ));
    }
    printf("Inserted %d elements \n", myQ->getSize(myQ));
    for (j = 0; j < QUEUE_SIZE; j++) {
        t = myQ->tail;
        k = myQ->remove(myQ);
        printf("REMOVE %d at position %d, size = %d\n", k, t, myQ->getSize(myQ));
    }
    printf("Last item removed = %d\n", k);
    printf("Current queu size %d\n", myQ->getSize(myQ));
    puts("Queue test program");
    return EXIT_SUCCESS;
}

二、继承

/* cached_queue.h =========================================*/
#ifndef _CACHED_QUEUE_H
#define _CACHED_QUEUE_H

#include "queue.h"

typedef struct CachedQueue CachedQueue;
struct CachedQueue {
    Queue *queue;    /* base class */
    
    /* new attrbutes */
    char finename[80];
    int numberElementsOnDisk;
    /* aggregation in subclass */
    Queue *outputQueue;
    
    /*inherited virtual function */
    int (*isFull)(CachedQueue *const me);
    int (*isEmpty)(CachedQueue *const me);
    int (*getSize)(CachedQueue *const me);
    void (*insert)(CachedQueue *const me, int k);
    int (*remove)(CachedQueue *const me);
    /* new virtual functions */
    void (*flush)(CachedQueue *const me);
    void (*load)(CachedQueue *const me);
};

void CachedQueue_Init(CachedQueue *const me, char *fName,
                int (*isFullfunction)(CachedQueue *const me),
                int (*ifEmptyfunction)(CachedQueue *const me),
                int (*getSizefunction)(CachedQueue *const me),
                int (*insertfunction)(CachedQueue *const me, int k),
                int (*removefunction)(CachedQueue *const me),
                int (*flushfunction)(CachedQueue *const me),
                void (*loadfunction)(CachedQueue *const me));

void CachedQueue_Cleanup(CachedQueue *const me);

/* operations */
int CacheQueue_ifFull(CachedQueue *const me);
int CacheQueue_ifEmpty(CachedQueue *const me);
int CacheQueue_getSize(CachedQueue *const me);
int CacheQueue_insert(CachedQueue *const me, int k);
int CacheQueue_remove(CachedQueue *const me);
int CacheQueue_flush(CachedQueue *const me);
int CacheQueue_load(CachedQueue *const me);

CachedQueue *cachedQueue_create(void);
void CachedQueue_destroy(CachedQueue *const me);

#endif /* _CACHED_QUEUE_H */

/* cached_queue.c =====================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cachedqueu.h"


void CachedQueue_Init(CachedQueue *const me, char *fName,
                int (*isFullfunction)(CachedQueue *const me),
                int (*ifEmptyfunction)(CachedQueue *const me),
                int (*getSizefunction)(CachedQueue *const me),
                int (*insertfunction)(CachedQueue *const me, int k),
                int (*removefunction)(CachedQueue *const me),
                int (*flushfunction)(CachedQueue *const me),
                void (*loadfunction)(CachedQueue *const me))
{
    /* initialize base class */
    me->queue = Queue_cteate();
    
    /* initialize subclass attributes */
    me->numberElementsOnDisk = 0;
    strcpy(me->filename, fName);
    
    me->outputQueue = Queue_Create();
    
    me->isFull= ifFullfunction;
    me->isEmpty = isEmptyfunction;
    me->getSize = getSizefunction;
    me->insert = insertfunction;
    me->remove = removefunction;
    me->flush = flushfunction;
    me->load = loadfunction;
}

void CachedQueue_Cleanup(CachedQueue *const me)
{
    Queue_Cleanup(me->queue);
}

/* operations */
int CacheQueue_isFull(CachedQueue *const me)
{
    return me->queue->isFull(me->queue) &&
            me->outputQueue->isFull(me->outputQueue);
}
int CacheQueue_isEmpty(CachedQueue *const me)
{
    return me->queue->isEmpty(me->queue) &&
            me->outputQueue->isEmpty(me->outputQueue) &&
            (me->nujmberElementsOnDisk == 0);
}
int CacheQueue_getSize(CachedQueue *const me)
{
    return me->queue->getSize(me->queue) + 
            me->outputQueue->getSize(me->outputQueue) +
            me->numberElementsOnDisk;
}
int CacheQueue_insert(CachedQueue *const me, int k);
{
    if (me->queue->isFull(me->queue))
        me->flush(me);
    me->queue->insert(me->queue, k);
}
int CacheQueue_remove(CachedQueue *const me)
{
    if(!me->outputQueue->isEmpty(me->outputQueue))
        return me->outputQueue->remove(me->outputQueue);
    else if(me->numberElementsOnDisk > 0) {
        me->load(me);
        return me->queue->remove(me->queue);
    }
    else
        return me->queue->remove(me->queue);
}
int CacheQueue_flush(CachedQueue *const me)
{
    //write file I/O
}
int CacheQueue_load(CachedQueue *const me)
{
    //read file I/O
}

CachedQueue *cachedQueue_Create(void)
{
    CachedQueue *me = (CachedQueue *)malloc(sizeof(CachedQueue ));
    if(me != NULL) {
        CachedQueue_list(me, "C:\\queuebuffer.dat",
                    CachedQueue_isFull, CachedQueue_isEmpty,
                    CachedQueue_getSize, CachedQueue_insert, CachedQueue_remove, 
                    CachedQueue_flush, CachedQueue_load);
    }
    return me;
}
void CachedQueue_destroy(CachedQueue *const me)
{
    if(me != NULL) {
        CachedQueue_Cleanup(me);
    }
    free(me);
}

小可嵌入式
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列（Queue）的C语言实现
乘风破浪会有时
08-18 2万+
队列的实现是一种先进先出的策略。以下使用动态分配内存的数组来实现一个队列。其中，队列的resize过程将不会保留原来队列中的item。//Item.h typedef struct ITEM { int key; void * statellite; } item_t;//Queue.h #ifndef STDIO_H #define STDIO_H #include <stdio.
队列及其c语言实现
热门推荐
林贻民的博客
08-14 2万+
队列的基本概念队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。 队首 (front) :允许进行删除的一端称为队首。 队尾 (rear) :允许进行插入的一端称为队尾。队列中没有元素时称为空队列。在空队列中依次加入元素 a 1 , a 2 , …, a n 之后, a
队列的封装
kevin980123的编程世界
11-10 553
队列的封装 程序代码如下： Queue.h //封装队列 typedef int QDataType; //typedef struct BTNode* QDataType; typedef struct QListNode { struct QListNode* _pNext; QDataType _data; }QListNode; typedef struct Queu...
纯c封装的一个队列
silence1214的专栏
06-02 1498
<br />纯C封装的，来看看吧<br />分为queue.h queue.c main.c<br />分别如下：<br /> <br /> <br /> // 定义数据域的数据结构，这里为了简单期间数据域有2个简单的属性组成。 struct business_data { char name[50]; int age; }; // 定义队列的节点数据节点 struct queue_node { // 为了节约运行时期的内存，我们这里用指针来指向业务数据的节点，具体使用请根据实际
C语言实现队列（纯C）
weixin_30352191的博客
09-05 192
1. [代码][C/C++]代码 #include <stdio.h>#include <stdlib.h>#define ElemType int#define Status int#define OK 1#define ERROR 0typedef struct QNode{ ElemType data; struct QNode *next;}Q...
c语言TCP/UDP程序例程
11-23
4. **监听（服务器）**：对于服务器端，调用`listen()`函数设置最大连接队列长度，等待客户端连接。 5. **连接（客户端/服务器）**：客户端使用`connect()`函数发起连接请求，服务器端使用`accept()`函数接收连接...
c语言 程序 100个 指针 数组
10-31
本资源摘要信息涵盖了 C 语言程序设计的 100 个经典例程，涵盖了指针、数组、链表等多种知识点。这些例程涵盖了基本的数据类型、运算符、控制结构、函数、数组、指针、链表、文件操作等多个方面的知识点。 指针 在...
宋劲彬的嵌入式C语言一站式编程
03-12
1. TCP/IP协议栈与数据包封装 2. 以太网(RFC 894)帧格式 3. ARP数据报格式 4. IP数据报格式 5. IP地址与路由 6. UDP段格式 7. TCP协议 7.1. 段格式 7.2. 通讯时序 7.3. 流量控制 37. socket编程 1. 预备知识 1.1. ...
freescale XDP512 AD采集数字量例程代码
03-01
开发者需要设计一个有效的数据队列或环形缓冲区机制，确保数据的稳定传输和处理。 6. **误差校正**：ADC的转换结果可能存在误差，需要对数据进行校准以提高精度，这可能涉及到线性校正、温度补偿等算法。 7. **...
C++典型程序源代码
06-17
C++是C语言的扩展，增加了类和对象的概念，引入了面向对象编程（OOP）。OOP允许我们将数据和操作数据的方法封装在一起，形成一个独立的实体——对象。通过继承、多态和封装，C++能够实现模块化和代码重用，提高软件...
c语言实现任何数据类型的queue（队列）(动态数组，链表)
Xin_Yue_Gu的博客
04-22 4190
模仿C++ STL的queue中函数命名 大部分名字都相同，快速上手
数据结构——队列的C语言代码实现
AZ10000000的博客
05-05 3976
系列文章目录 数据结构——顺序表的C语言代码实现 数据结构——八种链表的C语言代码实现 数据结构——栈的C语言代码实现 文章目录系列文章目录前言一、基础知识队列的概念（queue）二、代码实现1.queue.h2.queue.c3.test.c总结 前言 主要实现链式队列。 提示：以下是本篇文章正文内容，下面案例可供参考 一、基础知识 队列的概念（queue） 援引百科： 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，
C语言笔记(14)数据结构-队列的实现及应用
qq_37363920的博客
07-06 950
相当于排队买票,公平公正 , ,只允许在表尾插入数据, 只允许在表头删除数据, 而栈 是只允许在一头插入和删除数据
c语言实现队列
m0_61438674的博客
10-05 5324
c语言实现队列
Linux进程间通信-消息队列（IPC、mq）C/C++代码接口
zhoubiaodi的博客
03-15 3126
linux下C语言进程通信--消息列队，可用于多个进程之间通信，也可在一个进程内部当作队列来使用，只有简单的5个函数（创建、发送、堵塞接收、非堵塞接收、删除）
入门数据结构，c语言实现循环队列实现（详细篇）。
最新发布
A2202333的博客
11-08 4969
队列中的一个分支循环队列，运用了一些技巧降低了其时间复杂度与空间复杂度，学会循环队列可以帮助更好的学习后面复杂的结构（如：树，二叉树，图等）。
数据结构（2）队列实现（queue）
cdut2016的博客
09-07 1392
一、队列介绍 1、队列是一个有序列表，可以用数组或者链表实现。 2、遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 3、示意图： 数组模拟队列 1、队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。 2、因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示: 思路： 当我们将数
C语言实现队列
qq_45772965的博客
10-07 1602
C语言实现队列基本操作-初始化，入队，出队，打印，删除 C语言： #include <stdio.h> #include <stdlib.h> // 队列的实现 #define OVERFLOW -2 #define OK 1 #define ERROR 0 typedef int Status; typedef int QElemType; typedef struct QNode{ QElemType data; struct QNode * next; }QNo
C语言程序设计第三版
06-02
总结起来，C语言程序设计第三版是一本教授C语言编程的书籍，其中包含了各种C语言程序设计的初级例程和课后习题。本篇描述中我们列举了两个例题，一个是输出特定信息的程序，另一个是比较三个数并输出最大值的程序。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值