Rust双端队列库bounded-vec-deque的使用，高效实现容量受限的环形缓冲区与队列操作

安装

在项目目录中运行以下Cargo命令：

cargo add bounded-vec-deque

或在Cargo.toml中添加以下行：

bounded-vec-deque = "0.1.1"

使用示例

以下是一个使用bounded-vec-deque实现容量受限的环形缓冲区的完整示例：

use bounded_vec_deque::BoundedVecDeque;

fn main() {
    // 创建一个容量为5的双端队列
    let mut deque = BoundedVecDeque::new(5);

    // 从前面推入元素
    deque.push_front(1);
    deque.push_front(2);
    deque.push_front(3);
    
    println!("队列内容: {:?}", deque); // 输出: [3, 2, 1]

    // 从后面推入元素
    deque.push_back(4);
    deque.push_back(5);
    
    println!("队列已满: {:?}", deque); // 输出: [3, 2, 1, 4, 5]

    // 继续推入会移除最老的元素
    deque.push_back(6);
    
    println!("队列循环后: {:?}", deque); // 输出: [2, 1, 4, 5, 6]

    // 从前面弹出元素
    let front = deque.pop_front();
    println!("弹出前面元素: {:?}, 剩余队列: {:?}", front, deque); // 输出: Some(2), [1, 4, 5, 6]

    // 从后面弹出元素
    let back = deque.pop_back();
    println!("弹出后面元素: {:?}, 剩余队列: {:?}", back, deque); // 输出: Some(6), [1, 4, 5]

    // 检查队列是否为空
    println!("队列是否为空: {}", deque.is_empty()); // 输出: false

    // 获取队列长度
    println!("队列长度: {}", deque.len()); // 输出: 3

    // 获取队列容量
    println!("队列容量: {}", deque.capacity()); // 输出: 5
}

主要功能

bounded-vec-deque提供了以下主要功能：

容量受限的双端队列实现
当队列满时自动移除最老的元素
支持从队列两端高效地推入(push)和弹出(pop)元素
提供环形缓冲区功能
检查队列状态的方法(is_empty, len, capacity等)

这个库非常适合需要固定大小缓冲区的场景，如日志记录、消息队列等。

完整示例代码

以下是一个更完整的示例，展示了bounded-vec-deque的各种用法：

use bounded_vec_deque::BoundedVecDeque;

fn main() {
    // 1. 创建不同容量的队列
    let mut deque1 = BoundedVecDeque::new(3);  // 容量为3
    let mut deque2 = BoundedVecDeque::new(5);  // 容量为5
    
    // 2. 基本操作
    deque1.push_back(10);
    deque1.push_front(20);
    println!("deque1: {:?}", deque1);  // 输出: [20, 10]
    
    // 3. 队列满时自动移除最老元素
    deque1.push_back(30);
    deque1.push_back(40);  // 20会被移除
    println!("满队列: {:?}", deque1);  // 输出: [10, 30, 40]
    
    // 4. 获取队列状态
    println!("长度: {}, 容量: {}", deque1.len(), deque1.capacity());
    println!("是否为空: {}", deque1.is_empty());
    
    // 5. 迭代器使用
    println!("迭代元素:");
    for item in &deque1 {
        println!("{}", item);
    }
    
    // 6. 批量操作
    let values = [1, 2, 3, 4, 5];
    for &v in &values {
        deque2.push_back(v);
    }
    println!("批量添加后: {:?}", deque2);
    
    // 7. 清空队列
    deque2.clear();
    println!("清空后: {:?}", deque2);
    
    // 8. 检查元素是否存在
    deque2.extend([10, 20, 30]);
    println!("包含20: {}", deque2.contains(&20));
    
    // 9. 获取前后元素
    println!("前面元素: {:?}", deque2.front());
    println!("后面元素: {:?}", deque2.back());
    
    // 10. 容量变化
    deque2.reserve(10);
    println!("新容量: {}", deque2.capacity());
}

这个完整示例展示了bounded-vec-deque库的主要功能，包括：

创建不同容量的队列
基本推入/弹出操作
队列满时的自动处理
队列状态检查
迭代器使用
批量操作
清空队列
元素检查
容量调整等

通过这些示例，您可以全面了解如何在Rust项目中使用bounded-vec-deque来实现高效的容量受限队列和环形缓冲区。

gougou168 1楼

Rust双端队列库bounded-vec-deque的使用指南

介绍

bounded-vec-deque是一个Rust库，提供了容量受限的双端队列(Deque)实现，特别适合用作环形缓冲区。它比标准库的VecDeque更高效，因为它避免了动态内存分配，在创建时就固定了容量。

主要特性

固定容量，避免运行时内存分配
提供与标准库VecDeque相似的API
高效的环形缓冲区实现
支持双端操作(push/pop front/back)
零依赖

使用方法

添加依赖

首先在Cargo.toml中添加依赖：

[dependencies]
bounded-vec-deque = "0.1"

基本使用示例

use bounded_vec_deque::BoundedVecDeque;

fn main() {
    // 创建一个容量为5的双端队列
    let mut deque = BoundedVecDeque::new(5);
    
    // 从后端推入元素
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    
    // 从前端推入元素
    deque.push_front(0);
    
    println!("当前队列: {:?}", deque); // 输出: [0, 1, 2, 3]
    
    // 从前端弹出元素
    let front = deque.pop_front();
    println!("弹出前端: {:?}, 剩余队列: {:?}", front, deque);
    
    // 从后端弹出元素
    let back = deque.pop_back();
    println!("弹出后端: {:?}, 剩余队列: {:?}", back, deque);
}

环形缓冲区示例

use bounded_vec_deque::BoundedVecDeque;

fn main() {
    let mut buffer = BoundedVecDeque::new(3);
    
    // 填充缓冲区
    buffer.push_back(1);
    buffer.push_back(2);
    buffer.push_back(3);
    
    println!("缓冲区满: {:?}", buffer); // [1, 2, 3]
    
    // 继续添加会覆盖最旧的数据
    buffer.push_back(4);
    println!("覆盖后: {:?}", buffer); // [2, 3, 4]
    
    // 迭代缓冲区
    for item in &buffer {
        println!("缓冲区项: {}", item);
    }
}

其他常用操作

use bounded_vec_deque::BoundedVecDeque;

fn main() {
    let mut deque = BoundedVecDeque::new(4);
    
    // 批量添加元素
    deque.extend([1, 2, 3]);
    
    // 检查容量和长度
    println!("容量: {}, 长度: {}", deque.capacity(), deque.len());
    
    // 随机访问
    println!("第二个元素: {}", deque[1]);
    
    // 修改元素
    deque[1] = 5;
    
    // 清空队列
    deque.clear();
    
    // 检查是否为空
    println!("队列是否为空: {}", deque.is_empty());
}

完整示例代码

use bounded_vec_deque::BoundedVecDeque;

fn main() {
    // 示例1: 基本双端队列操作
    println!("===== 基本双端队列操作 =====");
    let mut deque = BoundedVecDeque::new(4);
    
    // 从后端添加元素
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    
    // 从前端添加元素
    deque.push_front(0);
    
    println!("队列内容: {:?}", deque); // [0, 1, 2, 3]
    
    // 弹出元素
    println!("弹出前端: {:?}", deque.pop_front()); // Some(0)
    println!("弹出后端: {:?}", deque.pop_back());  // Some(3)
    
    // 示例2: 环形缓冲区行为
    println!("\n===== 环形缓冲区行为 =====");
    let mut buffer = BoundedVecDeque::new(3);
    
    buffer.push_back(10);
    buffer.push_back(20);
    buffer.push_back(30);
    println!("缓冲区满: {:?}", buffer); // [10, 20, 30]
    
    // 继续添加会覆盖最旧元素
    buffer.push_back(40);
    println!("覆盖后: {:?}", buffer); // [20, 30, 40]
    
    // 示例3: 批量操作和随机访问
    println!("\n===== 批量操作和随机访问 =====");
    let mut queue = BoundedVecDeque::new(5);
    queue.extend([1, 2, 3, 4]);
    
    // 随机访问和修改
    println!("第二个元素: {}", queue[1]); // 2
    queue[1] = 99;
    println!("修改后: {:?}", queue); // [1, 99, 3, 4]
    
    // 容量和长度
    println!("容量: {}, 长度: {}", queue.capacity(), queue.len());
    
    // 清空队列
    queue.clear();
    println!("清空后是否为空: {}", queue.is_empty());
}

性能提示

bounded-vec-deque在创建时就分配了固定内存，后续操作不会有内存分配开销
对于已知最大容量的场景，它比标准库的VecDeque更高效
当队列满时，继续添加元素会自动覆盖最旧的元素(环形缓冲区行为)

与标准库VecDeque的区别

特性	bounded-vec-deque	标准库 VecDeque
固定容量	是	否
运行时内存分配	无	有
环形缓冲区行为	是	否
初始内存占用	固定	动态增长

这个库特别适合需要严格控制内存使用或实现环形缓冲区的场景。