# ring_buffer

**Repository Path**: jiang-xiaojian/ring_buffer

## Basic Information

- **Project Name**: ring_buffer
- **Description**: 这是一个简单的环形缓冲区实现，适用于C语言。环形缓冲区是一种高效的数据结构，常用于数据流的读写操作，例如在嵌入式系统和数据通信中。
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2025-08-21
- **Last Updated**: 2025-11-13

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README



# 环形缓冲区 (Ring Buffer)

这是一个简单的环形缓冲区实现，适用于C语言。环形缓冲区是一种高效的数据结构，常用于数据流的读写操作，例如在嵌入式系统和数据通信中。

## 功能特点

- 支持动态创建和删除缓冲区
- 支持数据的写入和读取
- 高效处理缓冲区满和空的状态
- 自动回绕指针以优化内存使用

## 函数说明

### `ring_buffer_t *ring_buffer_create(size_t size)`
- **描述**: 创建一个环形缓冲区并分配内存。
- **参数**:
  - `size`：缓冲区的大小（字节数）。
- **返回值**: 成功时返回指向缓冲区的指针，失败返回 `NULL`。

### `int ring_buffer_delete(ring_buffer_t *ring_buffer)`
- **描述**: 删除环形缓冲区并释放内存。
- **参数**:
  - `ring_buffer`：指向要删除的缓冲区。
- **返回值**: 返回 `RING_BUFFER_OK` 表示成功，否则表示错误。

### `int ring_buffer_write(ring_buffer_t *ring_buffer, const uint8_t *data, size_t size)`
- **描述**: 将数据写入环形缓冲区。
- **参数**:
  - `ring_buffer`：指向缓冲区。
  - `data`：要写入的数据。
  - `size`：数据的大小。
- **返回值**: 
  - `RING_BUFFER_OK`：成功写入。
  - `RING_BUFFER_NO_SPACE`：缓冲区空间不足。
  - `RING_BUFFER_FULL`：缓冲区已满。
  - `RING_BUFFER_ERROR`：输入参数无效。

### `int ring_buffer_read(ring_buffer_t *ring_buffer, uint8_t *data, size_t size)`
- **描述**: 从环形缓冲区读取数据。
- **参数**:
  - `ring_buffer`：指向缓冲区。
  - `data`：用于存储读取数据的缓冲区。
  - `size`：要读取的数据大小。
- **返回值**: 
  - `RING_BUFFER_OK`：成功读取。
  - `RING_BUFFER_READ_INSUFFICIENT`：缓冲区中数据不足。
  - `RING_BUFFER_ERROR`：输入参数无效。

## 错误代码

以下为定义的错误代码：
- `RING_BUFFER_OK`：操作成功。
- `RING_BUFFER_ERROR`：操作失败，参数错误或内存分配问题。
- `RING_BUFFER_FULL`：缓冲区已满。
- `RING_BUFFER_EMPTY`：缓冲区为空。
- `RING_BUFFER_NO_SPACE`：缓冲区可用空间不足。
- `RING_BUFFER_READ_INSUFFICIENT`：缓冲区中没有足够的数据可供读取。

## 许可证

该项目使用 MIT 许可证，详情请查看仓库文件。

## 示例


```
//test
int main(void)
{
    // 示例代码可以在这里测试环形缓冲区的功能
    size_t buffer_size = 10;
    ring_buffer_t *buffer = ring_buffer_create(buffer_size);
    if (!buffer)
    {
        printf("Failed to create ring buffer\n");
        return RING_BUFFER_ERROR;
    }


    //1
    uint8_t data_to_write[] = {1, 2, 3, 4, 5, 6};
    int write_result = ring_buffer_write(buffer, data_to_write, sizeof(data_to_write));
    if (write_result != RING_BUFFER_OK)
    {
        printf("Failed to write to ring buffer: %d\n", write_result);
    }


    //2
    write_result = ring_buffer_write(buffer, data_to_write, sizeof(data_to_write));
    if (write_result != RING_BUFFER_OK)
    {
        printf("Failed to write to ring buffer: %d\n", write_result);
    }

    write_result = ring_buffer_write(buffer, data_to_write, sizeof(data_to_write));
    if (write_result != RING_BUFFER_OK)
    {
        printf("Failed to write to ring buffer: %d\n", write_result);
    }

    //3
    uint8_t data_to_read[6];
    int read_result = ring_buffer_read(buffer, data_to_read, sizeof(data_to_read));
    if (read_result != RING_BUFFER_OK)
    {
        printf("Failed to read from ring buffer: %d\n", read_result);
    }
    else
    {
        printf("Read data: ");
        for (size_t i = 0; i < sizeof(data_to_read); i++)
        {
            printf("%d ", data_to_read[i]);
        }
        printf("\n");
    }

    //4
    write_result = ring_buffer_write(buffer, data_to_write, sizeof(data_to_write));
    if (write_result != RING_BUFFER_OK)
    {
        printf("Failed to write to ring buffer: %d\n", write_result);
    }


    //5
    read_result = ring_buffer_read(buffer, data_to_read, sizeof(data_to_read));
    if (read_result != RING_BUFFER_OK)
    {
        printf("Failed to read from ring buffer: %d\n", read_result);
    }
    else
    {
        printf("Read data: ");
        for (size_t i = 0; i < sizeof(data_to_read); i++)
        {
            printf("%d ", data_to_read[i]);
        }
        printf("\n");
    }

    //6
    read_result = ring_buffer_read(buffer, data_to_read, sizeof(data_to_read));
    if (read_result != RING_BUFFER_OK)
    {
        printf("Failed to read from ring buffer: %d\n", read_result);
    }
    else
    {
        printf("Read data: ");
        for (size_t i = 0; i < sizeof(data_to_read); i++)
        {
            printf("%d ", data_to_read[i]);
        }
        printf("\n");
    }

    read_result = ring_buffer_read(buffer, data_to_read, sizeof(data_to_read));
    if (read_result != RING_BUFFER_OK)
    {
        printf("Failed to read from ring buffer: %d\n", read_result);
    }
    else
    {
        printf("Read data: ");
        for (size_t i = 0; i < sizeof(data_to_read); i++)
        {
            printf("%d ", data_to_read[i]);
        }
        printf("\n");
    }

    ring_buffer_delete(buffer);
    return RING_BUFFER_OK;
}
```