嵌入式--队列容器

嵌入式–队列容器

直接上代码，自己体会。

头文件 queue.h

#ifndef __QUEUE_H_
#define __QUEUE_H_

#include <stdint.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    void *base;                            /*队列容器基地址*/
    uint16_t element_size;                 /*队列元素大小*/
    uint16_t size;                         /*队列容器可容纳元素个数*/
    uint16_t front;                        /*队首*/
    uint16_t rear;                         /*队尾*/
}queue_t;

bool QueueCreate(queue_t *q,  void *container, int size, int element_size); 

bool QueuePeek(queue_t *q,  void **element);

bool QueuePut(queue_t *q,  void *element);

bool QueueGet(queue_t *q,  void *element);

bool QueueDelete(queue_t *q);

void QueueClear(queue_t *q);

int QueueSize(queue_t *q);

#ifdef __cplusplus
}
#endif

#endif

源文件 queue.c

#include <stddef.h>
#include <string.h>

#include "queue.h"

bool QueueCreate(queue_t *q, void *base, int size, int element_size)
{
    if (q == NULL || base == NULL || size== 0 || element_size == 0)
    {
        return false;
    }
    
    q->base         = base;
    q->size         = size;
    q->element_size = element_size;
    q->front        = q->rear = 0;
    return true;
}

static bool QueueIsEmpty(queue_t *q)
{
    return q->front == q->rear;
}

static bool QueueIsFull(queue_t *q)
{
    return (q->rear + 1) % q->size == q->front;
}

bool QueuePut(queue_t *q,  void *element)
{
    if (QueueIsFull(q))
    {
        return false;
    }
    
    memcpy((unsigned char *)q->base + q->rear * q->element_size, element, q->element_size);
    q->rear = (q->rear + 1) % q->size;
    return true;
}

bool QueueGet(queue_t *q,  void *element)
{
    if (QueueIsEmpty(q))
    {
        return false;   
    }
    memcpy(element, (unsigned char *)q->base + q->front * q->element_size, q->element_size);
    q->front = (q->front + 1) % q->size;
    return true;
}

bool QueuePeek(queue_t *q, void **element)
{
    if (QueueIsEmpty(q))
    {
        return false;   
    }
    
    *element = (void *)((unsigned char *)q->base + q->front * q->element_size);
    return true;
}

bool QueueDelete(queue_t *q)
{
    if (QueueIsEmpty(q))
    {
        return false;   
    }
    q->front = (q->front + 1) % q->size;
    return true;
}

int QueueSize(queue_t *q)
{
    return (q->rear + q->size - q->front ) % q->size;
}

void QueueClear(queue_t *q)
{
    q->front = q->rear = 0;
}