C++ /C/MCU 实用算法/库总结(FIFO)

FIFO

//
// 文件：config.h
//
#ifndef __CONFIG_H 
#define __CONFIG_H
#ifndef TRUE
#define TRUE  1
#endif
#ifndef FALSE
#define FALSE 0
#endif
typedef unsigned char  uint8;                   
typedef signed   char  int8;                    
typedef unsigned short uint16;                  
typedef signed   short int16;                   
typedef unsigned int   uint32;                  
typedef signed   int   int32;                   
typedef float          fp32;                    
 
＃include "FIFOQUEUE.h"
#endif
 
 
 
 
//
// 文件：FIFOQUEUE.h
//
#ifndef _FIFOQUEUE_H
#define _FIFOQUEUE_H
#define ElemType       uint8
#define QueueSize      20 //fifo队列的大小
#define QueueFull      0  //fifo满置0
#define QueueEmpty     1  //FIFO空置1
#define QueueOperateOk 2  //队列操作完成 赋值为2
struct FifoQueue
{
    uint16 front;     //队列头，对头出数据
    uint16 rear;        //队列尾.队尾插入数据
    uint16 count;       //队列计数
    ElemType dat[QueueSize];
};
//Queue Initalize
void QueueInit(struct FifoQueue *Queue);
// Queue In
uint8 QueueIn(struct FifoQueue *Queue,ElemType sdat);
// Queue Out
uint8 QueueOut(struct FifoQueue *Queue,ElemType *sdat);
#endif
 
 
 
//
// 文件：FIFOQUEUE.C
//
＃include "config.h"
//Queue Init
void QueueInit(struct FifoQueue *Queue)
{
    Queue->front = Queue->rear;//初始化时队列头队列首相连
    Queue->count = 0;   //队列计数为0
}
// Queue In
uint8 QueueIn(struct FifoQueue *Queue,ElemType sdat) //数据进入队列
{//一次只能入一个数据，保证队尾rear不会超过队头font，最多相等
    if((Queue->front == Queue->rear) && (Queue->count == QueueSize))
    {      // full 判断如果队列满了，Queue->front == Queue->rear时也可能是空队列
               return QueueFull;    //返回队列满的标志
    }else
    {                    // in
        Queue->dat[Queue->rear] = sdat;//往队尾插入数据
        Queue->rear = (Queue->rear + 1) % QueueSize;//队尾在增长
        Queue->count = Queue->count + 1;
        return QueueOperateOk;
    }
}
// Queue Out
uint8 QueueOut(struct FifoQueue *Queue,ElemType *sdat)
{
    if((Queue->front == Queue->rear) && (Queue->count == 0))
    {                    // empty
        return QueueEmpty;
    }else
    {                    // out
        *sdat = Queue->dat[Queue->front];//出队从对头出
        Queue->front = (Queue->front + 1) % QueueSize;//对头也在增长，到数组                                         //                                                       //尾就重新回到数组开始
        Queue->count = Queue->count - 1;
        return QueueOperateOk;
    }
}
 
 
 
//
// 文件：Main.C
//
＃i nclude <reg52.h>
＃i nclude "config.h"
void main(void)
{
    struct FifoQueue MyQueue;
    ElemType sh;
    uint8 i;
    QueueInit(&MyQueue);
    while(1)
    {
        for(i = 0;i < 30;i++)
        {
            if(QueueIn(&MyQueue,i) == QueueFull) break;
        }
        for(i = 0;i < 30;i++)
        {
            if(QueueOut(&MyQueue,&sh) == QueueEmpty) break;
        }
    }
    while(1);
}

将数组臆想为首位相连的内存，图c是空队列，对头和队尾都指向同一个位置并且元素个数=0.

图a是队尾已经绕完一圈数组回到数组起点，队头已经输出了数组中的J0，J1，J2的数据

图b是满队列，对头和队尾都指向同一个位置并且元素个数=QueueSize.

最通俗的理解：把尾rear队尾理解为分针，把font队头理解为时针，分针总是跑的比时针快，只有分针跑了(FIFO中有数据)，时针队头才有数据输出。

fork()

linux中fork（）函数详解
https://www.cnblogs.com/dongguolei/p/8086346.html

libevent

libevent入门教程：Echo Server based on libevent
https://developer.aliyun.com/article/413601

libevent API 介绍
https://www.cnblogs.com/diegodu/p/4785391.html

json-c