c语言实现环形缓冲区

#include <stdio.h>
#include <string.h>

// 此缓冲区缺陷：数据可能会覆盖，写入的大小不能超过缓冲区大小
struct {
    char  *buffer; // 存储数据
    int   write;   // 写指针
    int   read;    // 读指针
    int   size;    // 缓冲区大小
}ring_buff_t;

// 初始化
int ring_buff_init(ring_buff_t * buff, int size)
{
    buff = (ring_buff_t)malloc(sizeof(ring_buff_t)); //申请内存
    if (buff == NULL) {
        printf("malloc error!\n");
        return -1;
    }
    memset(buff, 0, sizeof(ring_buff_t)); 

    buff->buffer = (char)malloc(size);
    memset(buff->buffer, 0, size);

    buff->write = 0;
    buff->read = 0;
    buff->size = size;
    return 0;
}

// 写入缓冲区
int ring_buff_write(ring_buff_t * buff, char *write, int write_len)
{
    int come_back_size = 0;           // buffer回头还要写的空间大小
    int remain_space = 0;             // 剩余空间
    if (buff == NULL) {
        return -1;
    }
    if (write == NULL) {
        return -1;
    }
    if (write_len > buff->size) {
        return -1;
    }

    // 写空间足够，不用回到头部
    if ((buff->write + write_len) <= buff->size) { 
        memcpy(buff->buffer + buff->write, write, write_len);
    } else {
        remain_space = buff->size - buff->write;
        come_back_size = write_len - remain_space;
        // 一部分数据写在尾部，一部分数据写在头部
        memcpy(buff->buffer + buff->write, write, remain_space);
        memcpy(buff->buffer, write + remain_space, come_back_size);
    }

    buff->write = (buff->write + write_len) % buff->size;
    return 0;
}

// 读取缓冲区
int ring_buff_read(ring_buff_t * buff, char *read, int read_len)
{
    int come_back_size = 0;           // buffer回头还要读的空间大小
    int remain_space = 0;             // 剩余空间
    if (buff == NULL) {
        return -1;
    }
    if (read == NULL) {
        return -1;
    }
    if (read_len > buff->size) {
        return -1;
    }

    if ((buff->read + read_len) <= buff->size) {
        memcpy(read, buff->buffer + buff->read, read_len);
    } else {
        remain_space = buff->size - buff->read;
        come_back_size = read_len - remain_space;
        memcpy(read, buff->buffer + buff->read, remain_space);
        memcpy(read + remain_space, buff->buffer, come_back_size);
    }

    buff->read = (buff->read + read_len) % buff->size;
    return 0;
}


// 计算缓冲区大小
int calculate_buff_size(ring_buff_t * buff, int buff_size)
{
    if (buff == NULL) {
        return -1;
    }

    // write指针可能在read指针前，也可能在read指针后
    if (buff->write > buff->read) {
        buff_size = buff->write - buff->read;
    } else {
        buff_size = (buff->size - buff->read) + buff->write;
    }

    return 0;
}

// 释放缓冲区
int ring_buff_free(ring_buff_t * buff)
{
    if (buff == NULL) {
        return -1;
    }

    if (buff->buffer != NULL) {
        free(buff->buffer);
        buff->buffer = NULL;
    }
    free(buff);
    buff = NULL;
}

// 判断缓冲区是否为空
int jude_buff_is_empty(ring_buff_t * buff)
{
    if (buff == NULL) {
        return -1;
    }
    if (buff->read == buff->write) {
        printf("缓冲区为空\n");
        return 0;
    }
    return 0;
}

int jude_buff_is_full(ring_buff_t * buff)
{
    if (buff == NULL) {
        return -1;
    }
    if (((buff->write + 1) % buff->size) == buff->read) {
        printf("缓冲区已满\n");
        return 0;
    }
    return 0;
}

int main(int argc, char **argv)
{
    

    return 0;
}