linuxc环形缓冲区代码

单线程

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

#define BUFFER_SIZE (8 * 1024 * 1024) // 8M

// 环形缓冲区结构
struct circular_buffer {
    char *buffer;
    unsigned int head; // 头指针
    unsigned int tail; // 尾指针
    unsigned int size; // 缓冲区大小
    unsigned int count; // 当前缓冲区的数据量
};

// 初始化缓冲区
int circular_buffer_init(struct circular_buffer *cb) {
    cb->size = BUFFER_SIZE;
    cb->buffer = malloc(cb->size);
    if (!cb->buffer) {
        perror("Failed to allocate memory for circular buffer");
        return -1;
    }
    cb->head = cb->tail = 0;
    cb->count = 0;
    return 0;
}

// 释放缓冲区
void circular_buffer_free(struct circular_buffer *cb) {
    free(cb->buffer);
}

// 获取缓冲区空闲空间
unsigned int circular_buffer_get_free_space(struct circular_buffer *cb) {
    return cb->size - cb->count;
}

// 获取缓冲区中已存储的数据量
unsigned int circular_buffer_get_data_count(struct circular_buffer *cb) {
    return cb->count;
}

// 向环形缓冲区写入数据
unsigned int circular_buffer_write(struct circular_buffer *cb, const char *data, unsigned int size) {
    unsigned int space = circular_buffer_get_free_space(cb);
    if (space < size) {
        return 0; // 空间不足写入任何数据
    }

    unsigned int i;
    for (i = 0; i < size; ++i) {
        cb->buffer[cb->head] = data[i];
        cb->head = (cb->head + 1) % cb->size;
        cb->count++;
    }

    return i; // 实际写入的数据长度
}

// 从环形缓冲区读取数据
unsigned int circular_buffer_read(struct circular_buffer *cb, char *data, unsigned int size) {
    unsigned int data_count = circular_buffer_get_data_count(cb);
    if (data_count == 0) {
        return 0; // 没有数据可读取
    }

    unsigned int i;
    for (i = 0; i < size && i < data_count; ++i) {
        data[i] = cb->buffer[cb->tail];
        cb->tail = (cb->tail + 1) % cb->size;
        cb->count--;
    }

    return i; // 实际读取的数据长度
}

// 打印缓冲区中的数据为16进制
void print_data(const char *data, unsigned int size) {
    for (unsigned int i = 0; i < size; ++i) {
        printf("%02X ", (unsigned char)data[i]);
    }
    printf("\n");
}

int main() {
    struct circular_buffer cb;
    char read_data[16];

    // 初始化环形缓冲区
    if (circular_buffer_init(&cb) != 0) {
        return -1;
    }

    // 写入16个字节的数据到环形缓冲区，比如简单的序列 0x00 到 0x0F
    char write_data[16];
    for (int i = 0; i < 16; ++i) {
        write_data[i] = i;
    }

    unsigned int len = circular_buffer_write(&cb, write_data, 16);
    if (len == 0) {
        printf("Insufficient space in circular buffer.\n");
    } else {
        printf("Successfully wrote %u bytes to circular buffer.\n", len);
    }

    // 判断缓冲区中是否有数据
    unsigned int data_count = circular_buffer_get_data_count(&cb);
    if (data_count == 0) {
        printf("No data available in circular buffer.\n");
    } else {
        unsigned int read_len = circular_buffer_read(&cb, read_data, 16);
        printf("Successfully read %u bytes from circular buffer.\n", read_len);
        // 打印读取的数据
        print_data(read_data, read_len);
    }

    // 释放环形缓冲区
    circular_buffer_free(&cb);

    return 0;
}

在上述代码中，我们为环形缓冲区添加了circular_buffer_get_data_count()函数来获取已存储的数据量，并在读取函数circular_buffer_read()中进行了数据存在性的判断。当缓冲区中没有数据可读取时，circular_buffer_read()函数将返回0。

在main函数中，我们先判断缓冲区中是否有数据可读取，如果没有，则输出相应的消息。如果有数据可读取，则获取实际读取的数据长度，并打印读取的数据的16进制形式。

需要注意的是，实际应用中可能需要根据具体需求进行更多的优化和处理错误的情况，这里只是对代码进行了简单的修改和优化。