【C++ STL】std::deque

阿米亚波2026-07-13 11:32

第一章 std::deque 核心函数列表与详解

1.1 构造函数

默认构造

  • 函数功能：创建一个空的双端队列。
  • 函数入参：无。
  • 函数返回值：无（构造对象）。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq;
std::cout << "[默认构造] deque size: " << dq.size() << ", empty: " << dq.empty() << std::endl;

填充构造

  • 函数功能：创建包含指定数量相同元素的双端队列。
  • 函数入参 ：count (元素数量), value (默认值)。
  • 函数返回值：无（构造对象）。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq(5, 42);
std::cout << "[填充构造] deque(5, 42): ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

范围构造

  • 函数功能 ：使用迭代器区间 [first, last) 内的元素进行构造。
  • 函数入参 ：first (起始迭代器), last (结束迭代器)。
  • 函数返回值：无（构造对象）。
  • 使用举例：
cpp 复制代码 
std::vector<int> vec = { 10, 20, 30, 40, 50 };
std::deque<int> dq(vec.begin(), vec.end());
std::cout << "[范围构造] from vector: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

拷贝构造

  • 函数功能：使用另一个 deque 的内容进行深拷贝构造。
  • 函数入参 ：other (另一个 deque 对象)。
  • 函数返回值：无（构造对象）。
  • 使用举例：
cpp 复制代码 
std::deque<int> original = { 1, 2, 3, 4, 5 };
std::deque<int> copied(original);
std::cout << "[拷贝构造] copied: ";
for (const auto& val : copied) std::cout << val << " ";
std::cout << std::endl;

移动构造

  • 函数功能：转移另一个 deque 的资源，原对象变为空。
  • 函数入参 ：other (右值引用)。
  • 函数返回值：无（构造对象）。
  • 使用举例：
cpp 复制代码 
std::deque<std::string> source = { "hello", "world", "deque" };
std::deque<std::string> moved(std::move(source));
std::cout << "[移动构造] moved: ";
for (const auto& val : moved) std::cout << val << " ";
std::cout << std::endl;

初始化列表构造

  • 函数功能 ：使用初始化列表 {...} 中的元素进行构造。
  • 函数入参 ：init (initializer_list)。
  • 函数返回值：无（构造对象）。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 100, 200, 300, 400, 500 };
std::cout << "[初始化列表] dq: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

1.2 赋值操作

operator=

  • 函数功能：替换容器内容（支持拷贝、移动、初始化列表）。
  • 函数入参：另一个 deque 对象、右值引用或初始化列表。
  • 函数返回值 ：*this (当前对象的引用)。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq1 = { 1, 2, 3 };
std::deque<int> dq2;
dq2 = dq1; // 拷贝赋值
std::cout << "[拷贝赋值] dq2: ";
for (const auto& val : dq2) std::cout << val << " ";
std::cout << std::endl;

assign (填充)

  • 函数功能：替换容器内容为指定数量的相同值。
  • 函数入参 ：count (数量), value (值)。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq;
dq.assign(6, 99);
std::cout << "[assign填充] dq: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

assign (范围)

  • 函数功能 ：替换容器内容为迭代器区间 [first, last) 的元素。
  • 函数入参 ：first, last (迭代器)。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq;
int arr[] = { 11, 22, 33, 44, 55 };
dq.assign(arr, arr + 5);
std::cout << "[assign范围] dq: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

assign (列表)

  • 函数功能：替换容器内容为初始化列表中的元素。
  • 函数入参 ：init (initializer_list)。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<std::string> dq;
dq.assign({ "apple", "banana", "cherry" });
std::cout << "[assign初始化列表] dq: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

1.3 元素访问

at

  • 函数功能：访问指定位置的元素，带越界检查。
  • 函数入参 ：pos (索引)。
  • 函数返回值：指向该元素的引用。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 10, 20, 30, 40, 50 };
std::cout << "[at] dq.at(2) = " << dq.at(2) << std::endl;
try {
    dq.at(100);
} catch (const std::out_of_range& e) {
    std::cout << "[at] 越界异常: " << e.what() << std::endl;
}

operator[]

  • 函数功能：访问指定位置的元素，无越界检查。
  • 函数入参 ：pos (索引)。
  • 函数返回值：指向该元素的引用。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 10, 20, 30, 40, 50 };
std::cout << "[operator[]] dq[0] = " << dq[0] << ", dq[4] = " << dq[4] << std::endl;
dq[1] = 888;
std::cout << "[operator[]] 修改后 dq[1] = " << dq[1] << std::endl;

front

  • 函数功能：访问容器的第一个元素。
  • 函数入参：无。
  • 函数返回值：指向首元素的引用。
  • 使用举例：
cpp 复制代码 
std::deque<std::string> dq = { "first", "second", "third" };
std::cout << "[front] " << dq.front() << std::endl;
dq.front() = "modified_first";
std::cout << "[front] 修改后: " << dq.front() << std::endl;

back

  • 函数功能：访问容器的最后一个元素。
  • 函数入参：无。
  • 函数返回值：指向尾元素的引用。
  • 使用举例：
cpp 复制代码 
std::deque<std::string> dq = { "first", "second", "thrid" };
std::cout << "[back] " << dq.back() << std::endl;
dq.back() = "modified_last";
std::cout << "[back] 修改后: " << dq.back() << std::endl;

1.4 迭代器

begin / end

  • 函数功能：获取指向首/尾元素（尾后）的正向迭代器。
  • 函数入参：无。
  • 函数返回值 ：iterator。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5 };
std::cout << "[begin/end] 正向遍历: ";
for (auto it = dq.begin(); it != dq.end(); it++) {
    std::cout << *it << " ";
}
std::cout << std::endl;

cbbegin / cend

  • 函数功能：获取指向首/尾元素的常量正向迭代器（只读）。
  • 函数入参：无。
  • 函数返回值 ：const_iterator。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 10, 20, 30, 40, 50 };
std::cout << "[cbegin/cend] const遍历: ";
for (auto it = dq.cbegin(); it != dq.cend(); it++) {
    std::cout << *it << " ";
}
std::cout << std::endl;

rbegin / rend

  • 函数功能：获取指向尾/首元素（首前）的反向迭代器。
  • 函数入参：无。
  • 函数返回值 ：reverse_iterator。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5 };
std::cout << "[rbegin/rend] 反向遍历: ";
for (auto it = dq.rbegin(); it != dq.rend(); it++) {
    std::cout << *it << " ";
}
std::cout << std::endl;

crbegin / crend

  • 函数功能：获取指向尾/首元素的常量反向迭代器（只读）。
  • 函数入参：无。
  • 函数返回值 ：const_reverse_iterator。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq{ 10, 20, 30, 40, 50 };
std::cout << "[crbegin/crend] const反向遍历: ";
for (auto it = dq.crbegin(); it != dq.crend(); it++) {
    std::cout << *it << " ";
}
std::cout << std::endl;

1.5 容量相关

empty

  • 函数功能：检查容器是否为空。
  • 函数入参：无。
  • 函数返回值 ：bool (true 为空)。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq1;
std::deque<int> dq2 = { 1, 2, 3 };
std::cout << "[empty] dq1: " << (dq1.empty() ? "空" : "非空") << std::endl;
std::cout << "[empty] dq2: " << (dq2.empty() ? "空" : "非空") << std::endl;

size

  • 函数功能：获取容器中的元素数量。
  • 函数入参：无。
  • 函数返回值 ：size_type (元素个数)。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5 };
std::cout << "[size] dq.size() = " << dq.size() << std::endl;
dq.push_back(6);
std::cout << "[size] push_back后 dq.size() = " << dq.size() << std::endl;

max_size

  • 函数功能：获取容器支持的最大元素数量。
  • 函数入参：无。
  • 函数返回值 ：size_type (最大容量)。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq;
std::cout << "[max_size] int deque max_size = " << dq.max_size() << std::endl;

shrink_to_fit

  • 函数功能：请求移除未使用的内存以减少容量。
  • 函数入参：无。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq;
for (int i = 0; i < 100; i++) dq.push_back(i);
while (dq.size() > 5) dq.pop_back();
dq.shrink_to_fit();
std::cout << "[shrink_to_fit] shrink_to_fit 后 size = " << dq.size() << std::endl;

resize

  • 函数功能：改变容器中存储的元素数量。
  • 函数入参 ：count (新大小), value (可选，填充值)。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5 };
dq.resize(8, 99); // 扩大
std::cout << "[resize] 扩大到8（默认99）: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

1.6 修改操作

clear

  • 函数功能：清除所有元素。
  • 函数入参：无。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5 };
dq.clear();
std::cout << "[clear] 清楚后 size = " << dq.size() << ", empty = " << dq.empty() << std::endl;

insert

  • 函数功能：在指定位置插入元素（支持单元素、填充、范围、列表）。
  • 函数入参 ：pos (迭代器), 值/数量/范围/列表。
  • 函数返回值：指向插入元素的迭代器。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3 };
auto it = dq.insert(dq.begin() + 2, 4); // 在索引2处插入4
std::cout << "[insert单元素] 插入后: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

emplace

  • 函数功能：在指定位置原地构造元素。
  • 函数入参 ：pos (迭代器), 构造参数。
  • 函数返回值：指向新元素的迭代器。
  • 使用举例：
cpp 复制代码 
std::deque<Student> students;
students.emplace_back("Zara", 20, 91.0);
auto it = students.emplace(students.begin() + 1, "Xander", 21, 95.0);
std::cout << "[emplace] 返回迭代器指向: " << *it << std::endl;

erase

  • 函数功能：移除指定位置或区间的元素。
  • 函数入参 ：pos 或 first, last (迭代器)。
  • 函数返回值：指向被擦除元素后一个元素的迭代器。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5 };
auto it = dq.erase(dq.begin() + 2); // 删除索引2的元素(3)
std::cout << "[erase单元素] 删除后: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

push_back

  • 函数功能：在容器末尾添加元素。
  • 函数入参 ：value (值)。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq;
for (int i = 1; i <= 5; i++) dq.push_back(i * 10);
std::cout << "[push_back] dq: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

push_front

  • 函数功能：在容器开头添加元素。
  • 函数入参 ：value (值)。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 3, 4, 5 };
dq.push_front(2);
dq.push_front(1);
std::cout << "[push_front] dq: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

emplace_back

  • 函数功能：在容器末尾原地构造元素。
  • 函数入参：构造参数。
  • 函数返回值 ：
    • void (C++17 前)
    • 对插入元素的引用。(C++17 起)
  • 使用举例：
cpp 复制代码 
std::deque<Student> students;
students.emplace_back("Alice", 22, 95.5);
students.emplace_back("Bob", 21, 88.0);

emplace_front

  • 函数功能：在容器开头原地构造元素。
  • 函数入参：构造参数。
  • 函数返回值 ：
    • void (C++17 前)
    • 对插入元素的引用。(C++17 起)
  • 使用举例：
cpp 复制代码 
std::deque<Student> students;
students.emplace_back("Bob", 21, 88.0);
students.emplace_front("Alice", 22, 95.0);  // 在头部原地构造

pop_back

  • 函数功能：移除容器末尾的元素。
  • 函数入参：无。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5 };
dq.pop_back();
std::cout << "[pop_back] 弹出后: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

pop_front

  • 函数功能：移除容器开头的元素。
  • 函数入参：无。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5 };
dq.pop_front();
std::cout << "[pop_front] 弹出后: ";
for (const auto& val : dq) std::cout << val << " ";
std::cout << std::endl;

1.7 swap 操作

swap

  • 函数功能：交换两个容器的内容。
  • 函数入参 ：other (另一个 deque)。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq1 = { 1, 2, 3 };
std::deque<int> dq2 = { 10, 20, 30, 40 };
dq1.swap(dq2);
std::cout << "[swap] 交换后 dq1: ";
for (const auto& val : dq1) std::cout << val << " ";
std::cout << std::endl;

1.8 非成员函数

std::swap

  • 函数功能：交换两个 deque 容器的内容。
  • 函数入参 ：lhs, rhs (两个 deque)。
  • 函数返回值 ：void。
  • 使用举例：
cpp 复制代码 
std::deque<int> a = { 1, 2, 3 };
std::deque<int> b = { 4, 5, 6, 7 };
std::swap(a, b);

比较运算符

  • 函数功能 ：比较两个 deque 的字典序 (==, !=, <, >, <=, >=)。
  • 函数入参 ：lhs, rhs。
  • 函数返回值 ：bool。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq1 = { 1, 2, 3 };
std::deque<int> dq2 = { 1, 2, 3 };
std::cout << "[==] dq1 == dq2: " << (dq1 == dq2) << std::endl;

std::erase

  • 函数功能：移除所有等于特定值的元素 (C++20，或使用 erase-remove 惯用法)。
  • 函数入参 ：c (容器), value (值)。
  • 函数返回值：被移除的元素数量。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 2, 4, 2, 5 };
auto count = std::erase(dq, 2); // C++20
// 或 dq.erase(std::remove(dq.begin(), dq.end(), 2), dq.end());

std::erase_if

  • 函数功能：移除所有满足谓词条件的元素 (C++20，或使用 erase-remove_if 惯用法)。
  • 函数入参 ：c (容器), pred (谓词)。
  • 函数返回值：被移除的元素数量。
  • 使用举例：
cpp 复制代码 
std::deque<int> dq = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
auto count = std::erase_if(dq, [](int x) {return x % 2 == 0; }); // C++20

第二章 分模块代码解析

2.1 自定义类型定义

定义了在 deque 中使用的自定义类 Student 和 Task，并重载了必要的运算符以支持比较和输出。

cpp 复制代码 
class Student
{
public:
    Student() = default;
    Student(std::string name, int age, double score)
        : name_(std::move(name)), age_(age), score_(score) { }
    // ... 拷贝/移动构造及赋值运算符重载 ...
    bool operator==(const Student& other) const { /*...*/ }
    bool operator<(const Student& other) const { /*...*/ }
    // ... 其他运算符及 getter/setter ...
    friend std::ostream& operator<<(std::ostream& os, const Student& s) { /*...*/ }
private:
    std::string name_;
    int age_ = 0;
    double score_ = 0.0;
};

class Task
{
public:
    Task() = default;
    Task(int id, std::string desc, int priority)
        : id_(id), description_(std::move(desc)), priority_(priority) { }
    // ... 运算符重载及 getter ...
    friend std::ostream& operator<<(std::ostream& os, const Task& t) { /*...*/ }
private:
    int id_ = 0;
    std::string description_;
    int priority_ = 0;
};

2.2 构造函数相关

展示了 deque 的 6 种构造方式：默认、填充、范围、拷贝、移动和初始化列表。

cpp 复制代码 
void demo_default_constructor() {
    std::deque<int> dq;
    std::cout << "[默认构造] deque size: " << dq.size() << ", empty: " << dq.empty() << std::endl;
}

void demo_fill_constructor() {
    std::deque<int> dq(5, 42);
    // ... 输出及自定义类型填充构造 ...
}

void demo_range_constructor() {
    std::vector<int> vec = { 10, 20, 30, 40, 50 };
    std::deque<int> dq(vec.begin(), vec.end());
    // ...
}
// 拷贝构造 / 移动构造 / 初始化列表构造 (详见完整代码)

2.3 赋值操作

演示了使用 = 和 assign 进行内容替换的各种方式。

cpp 复制代码 
void demo_copy_assignment() { /* dq2 = dq1; */ }
void demo_move_assignment() { /* dq2 = std::move(dq1); */ }
void demo_initializer_list_assignment() { /* dq = { 7, 8, 9, 10 }; */ }

void demo_assign_fill() { /* dq.assign(6, 99); */ }
void demo_assign_range() { /* dq.assign(arr, arr + 5); */ }
void demo_assign_initializer_list() { /* dq.assign({ "apple", "banana", "cherry" }); */ }

2.4 元素访问与迭代器

包含带边界检查的 at()、下标访问、首尾元素访问，以及正向/反向、常量/非常量迭代器的使用。

cpp 复制代码 
void demo_at() { /* dq.at(2); 捕获 out_of_range 异常 */ }
void demo_operator_bracket() { /* dq[0]; dq[1] = 888; */ }
void demo_front() { /* dq.front() = "modified_first"; */ }
void demo_back() { /* dq.back() = "modified_last"; */ }

void demo_begin_end() { /* 正向遍历并修改元素 */ }
void demo_cbegin_cend() { /* const 正向遍历 */ }
void demo_rbegin_rend() { /* 反向遍历 */ }
void demo_crbegin_crend() { /* const 反向遍历 */ }

2.5 容量相关与修改操作

涉及容量查询、调整，以及元素的插入、删除、原地构造和首尾推拉操作。

cpp 复制代码 
void demo_empty() { /* 检查是否为空 */ }
void demo_size() { /* 获取元素个数 */ }
void demo_max_size() { /* 获取最大容量 */ }
void demo_shrink_to_fit() { /* 释放多余内存 */ }
void demo_resize() { /* 扩大或缩小容器尺寸 */ }

void demo_insert_single() { /* dq.insert(dq.begin() + 2, 4); */ }
void demo_insert_fill() { /* dq.insert(dq.end(), 3, 88); */ }
void demo_insert_range() { /* dq.insert(pos, extra.begin(), extra.end()); */ }
void demo_insert_initializer_list() { /* dq.insert(pos, { "b", "c", "d" }); */ }
void demo_emplace() { /* students.emplace(pos, "Xander", 21, 95.0); */ }
void demo_erase_single() { /* dq.erase(dq.begin() + 2); */ }
void deme_erase_range() { /* dq.erase(first, last); */ }
void demo_push_back() / demo_push_front() { /* 尾部/头部添加 */ }
void demo_emplace_back() / demo_emplace_front() { /* 尾部/头部原地构造 */ }
void demo_pop_back() / demo_pop_front() { /* 尾部/头部移除 */ }

2.6 Swap、非成员函数与遍历方式

包含容器交换、C++20 的新式擦除函数、比较运算符，以及 4 种不同的遍历方式。

cpp 复制代码 
void demo_swap() { /* dq1.swap(dq2); */ }

void demo_std_swap() { /* std::swap(a, b); */ }
void demo_comparison_operators() { /* ==, !=, <, >, <=, >= */ }
void demo_std_erase() { /* std::erase(dq, 2); (或 erase-remove 惯用法) */ }
void demo_std_erase_if() { /* std::erase_if(dq, pred); */ }

void demo_range_for() { /* for (const auto& val : dq) */ }
void demo_iterator_traversal() { /* for (auto it = dq.begin(); ...) */ }
void demo_index_traversal() { /* for (size_t i = 0; i < dq.size(); i++) */ }
void demo_reverse_traversal() { /* for (auto it = dq.rbegin(); ...) */ }

2.7 与算法配合及实战场景

展示了 deque 与 STL 算法（sort, find, count, accumulate 等）的结合，以及在滑动窗口、消息队列、回文检测等实际场景中的应用。

cpp 复制代码 
void demo_sort() { /* std::sort, 自定义排序 */ }
void demo_find() { /* std::find, std::find_if */ }
void demo_count() { /* std::count, std::count_if */ }
void demo_accumulate() { /* std::accumulate 求和/求积 */ }
// ... copy, reverse, transform, for_each, predicates ...

void demo_sliding_window() { /* 使用 deque 存储索引实现滑动窗口最大值 */ }
void demo_message_queue() { /* 使用 push_back 和 push_front 模拟优先级任务队列 */ }
void demo_palindrome_check() { /* 首尾弹出元素检测回文 */ }
void demo_double_ended_buffer() { /* 固定大小的双端环形缓冲区 */ }

第三章 完整代码

cpp 复制代码 
#include<iostream>
#include<deque>
#include<vector>
#include<algorithm>
#include<numeric>
#include<string>
#include<cassert>
#include<functional>
#include<initializer_list>

/*
 * 自定义类型定义
 */

class Student
{
public:
    Student() = default;
    
    Student(std::string name, int age, double score)
        : name_(std::move(name)), age_(age), score_(score) { }

    Student(const Student& other)
        : name_(other.name_), age_(other.age_), score_(other.score_) { }

    Student(Student&& other) noexcept
        : name_(std::move(other.name_)), age_(other.age_), score_(other.score_) { }

    Student& operator=(Student other)
    {
        std::swap(name_, other.name_);
        std::swap(age_, other.age_);
        std::swap(score_, other.score_);
        return *this;
    }

    bool operator==(const Student& other) const
    {
        return name_ == other.name_ && age_ == other.age_ && score_ == other.score_;
    }

    bool operator!=(const Student& other) const
    {
        return !(*this == other);
    }

    bool operator<(const Student& other) const
    {
        return std::tie(score_, age_, name_) < 
            std::tie(other.score_, other.age_, other.name_);
    }

    bool operator>(const Student& other) const { return other < *this; }
    bool operator<=(const Student& other) const { return !(other < *this); }
    bool operator>=(const Student& other) const { return !(*this < other); }

    friend std::ostream& operator<<(std::ostream& os, const Student& s)
    {
        os << "Student{name=\"" << s.name_ << "\", age=" << s.age_
            << ", score=" << s.score_ << "}";
        return os;
    }

    const std::string& getName() const { return name_; }
    int getAge() const { return age_; }
    double getScore() const { return score_; }

    void setName(const std::string& name) { name_ = name; }
    void setAge(int age) { age_ = age; }
    void setScore(double score) { score_ = score; }

private:
    std::string name_;
    int age_ = 0;
    double score_ = 0.0;
};

class Task
{
public:
    Task() = default;
    Task(int id, std::string desc, int priority)
        : id_(id), description_(std::move(desc)), priority_(priority) { }
    Task(const Task&) = default;
    Task(Task&&) noexcept = default;
    
    Task& operator=(const Task&) = default;
    Task& operator=(Task&&) noexcept = default;

    bool operator==(const Task& other) const { return id_ == other.id_; }
    bool operator<(const Task& other) const { return priority_ < other.priority_; }

    friend std::ostream& operator<<(std::ostream& os, const Task& t)
    {
        os << "Task{id=" << t.id_ << ", desc=\"" << t.description_ 
            << "\", priority=" << t.priority_ << "}";
        return os;
    }

    int getId() const { return id_; }
    const std::string& getDescription() const { return description_; }
    int getPriority() const { return priority_; }

private:
    int id_ = 0;
    std::string description_;
    int priority_ = 0;
};

// ====================================================================

/*
 * 1. 构造函数相关
 */

// 1.1 默认构造
void demo_default_constructor()
{
    std::deque<int> dq;
    std::cout << "[默认构造] deque size: " << dq.size() << ", empty: " << dq.empty() << std::endl;
}

// 1.2 填充构造（指定数量 + 默认值）
void demo_fill_constructor()
{
    std::deque<int> dq(5, 42);
    std::cout << "[填充构造] deque(5, 42): ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    std::deque<Student> students(3, Student("Default", 20, 90.0));
    std::cout << "[填充构造-自定义类型] size: " << students.size() << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
}

// 1.3 范围构造（迭代器区间）
void demo_range_constructor()
{
    std::vector<int> vec = { 10, 20, 30, 40, 50 };
    std::deque<int> dq(vec.begin(), vec.end());
    std::cout << "[范围构造] from vector: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 1.4 拷贝构造
void demo_copy_constructor()
{
    std::deque<int> original = { 1, 2, 3, 4, 5 };
    std::deque<int> copied(original);
    std::cout << "[拷贝构造] copied: ";
    for (const auto& val : copied) std::cout << val << " ";
    std::cout << std::endl;
}

// 1.5 移动构造
void demo_move_constructor()
{
    std::deque<std::string> source = { "hello", "world", "deque" };
    std::deque<std::string> moved(std::move(source));
    std::cout << "[移动构造] moved: ";
    for (const auto& val : moved) std::cout << val << " ";
    std::cout << std::endl;
    std::cout << "[移动构造] source size after move: " << source.size() << std::endl;
}

// 1.6 初始化列表构造
void demo_initializer_list_constructor()
{
    std::deque<int> dq = { 100, 200, 300, 400, 500 };
    std::cout << "[初始化列表] dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    std::deque<Student> students = {
        Student("Alice", 22, 95.5),
        Student("Bob", 21, 88.0),
        Student("Charlie", 23, 92.3)
    };
    std::cout << "[初始化列表-自定义类型] size: " << students.size() << std::endl;
}

// ====================================================================

/*
* 2. 赋值操作
*/

// 2.1 operator= 拷贝赋值
void demo_copy_assignment()
{
    std::deque<int> dq1 = { 1, 2, 3 };
    std::deque<int> dq2;
    dq2 = dq1;
    std::cout << "[拷贝赋值] dq2: ";
    for (const auto& val : dq2) std::cout << val << " ";
    std::cout << std::endl;
}

// 2.2 operator= 移动赋值
void demo_move_assignment()
{
    std::deque<int> dq1 = { 10, 20, 30 };
    std::deque<int> dq2;
    dq2 = std::move(dq1);
    std::cout << "[移动赋值] dq2: ";
    for (const auto& val : dq2) std::cout << val << " ";
    std::cout << std::endl;
    std::cout << "[移动赋值] dq1 size after move: " << dq1.size() << std::endl;
}

// 2.3 operator= 初始化列表赋值
void demo_initializer_list_assignment()
{
    std::deque<int> dq;
    dq = { 7, 8, 9, 10 };
    std::cout << "[初始化列表赋值] dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 2.4 assign 填充赋值
void demo_assign_fill()
{
    std::deque<int> dq;
    dq.assign(6, 99);
    std::cout << "[assign填充] dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 2.5 assign 范围赋值
void demo_assign_range()
{
    std::deque<int> dq;
    int arr[] = { 11, 22, 33, 44, 55 };
    dq.assign(arr, arr + 5);
    std::cout << "[assign范围] dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 2.6 assign 初始化列表赋值
void demo_assign_initializer_list()
{
    std::deque<std::string> dq;
    dq.assign({ "apple", "banana", "cherry" });
    std::cout << "[assign初始化列表] dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// ====================================================================

/*
* 3. 元素访问
*/

// 3.1 at() 带边界检查访问
void demo_at()
{
    std::deque<int> dq = { 10, 20, 30, 40, 50 };
    std::cout << "[at] dq.at(2) = " << dq.at(2) << std::endl;

    try
    {
        dq.at(100);
    }
    catch (const std::out_of_range& e)
    {
        std::cout << "[at] 越界异常: " << e.what() << std::endl;
    }

    // 通过 at() 修改元素
    dq.at(0) = 999;
    std::cout << "[at] 修改后 dq.at(0) = " << dq.at(0) << std::endl;
}

// 3.2 operator[] 下标访问
void demo_operator_bracket()
{
    std::deque<int> dq = { 10, 20, 30, 40, 50 };
    std::cout << "[operator[]] dq[0] = " << dq[0] << ", dq[4] = " << dq[4] << std::endl;
    dq[1] = 888;
    std::cout << "[operator[]] 修改后 dq[1] = " << dq[1] << std::endl;
}

// 3.3 front() 访问首元素
void demo_front()
{
    std::deque<std::string> dq = { "first", "second", "third" };
    std::cout << "[front] " << dq.front() << std::endl;
    dq.front() = "modified_first";
    std::cout << "[front] 修改后: " << dq.front() << std::endl;
}

// 3.4 back() 访问尾元素
void demo_back()
{
    std::deque<std::string> dq = { "first", "second", "thrid" };
    std::cout << "[back] " << dq.back() << std::endl;
    dq.back() = "modified_last";
    std::cout << "[back] 修改后: " << dq.back() << std::endl;
}

// ====================================================================

/*
* 4. 迭代器
*/

// 4.1 begin/end 正向迭代器
void demo_begin_end()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::cout << "[begin/end] 正向遍历: ";
    for (auto it = dq.begin(); it != dq.end(); it++)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 通过迭代器修改元素
    for (auto it = dq.begin(); it != dq.end(); it++)
    {
        *it *= 10;
    }
    std::cout << "[begin/end] 修改后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 4.2 cbegin/cend const正向迭代器
void demo_cbegin_cend()
{
    std::deque<int> dq = { 10, 20, 30, 40, 50 };
    std::cout << "[cbegin/cend] const遍历: ";
    for (auto it = dq.cbegin(); it != dq.cend(); it++)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// 4.3 rbegin/rend 反向迭代器
void demo_rbegin_rend()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::cout << "[rbegin/rend] 反向遍历: ";
    for (auto it = dq.rbegin(); it != dq.rend(); it++)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// 4.4 crbegin/crend const反向迭代器
void demo_crbegin_crend()
{
    std::deque<int> dq{ 10, 20, 30, 40, 50 };
    std::cout << "[crbegin/crend] const反向遍历: ";
    for (auto it = dq.crbegin(); it != dq.crend(); it++)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// ====================================================================

/*
* 5. 容量相关
*/

// 5.1 empty()
void demo_empty()
{
    std::deque<int> dq1;
    std::deque<int> dq2 = { 1, 2, 3 };
    std::cout << "[empty] dq1: " << (dq1.empty() ? "空" : "非空") << std::endl;
    std::cout << "[empty] dq2: " << (dq2.empty() ? "空" : "非空") << std::endl;
}

// 5.2 size()
void demo_size()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::cout << "[size] dq.size() = " << dq.size() << std::endl;
    dq.push_back(6);
    std::cout << "[size] push_back后 dq.size() = " << dq.size() << std::endl;
}

// 5.3 max_size()
void demo_max_size()
{
    std::deque<int> dq;
    std::cout << "[max_size] int deque max_size = " << dq.max_size() << std::endl;

    std::deque<Student> students;
    std::cout << "[max_size] Student deque max_size = " << students.max_size() << std::endl;
}

// 5.4 shrink_to_fit()
void demo_shrink_to_fit()
{
    std::deque<int> dq;
    for (int i = 0; i < 100; i++)
    {
        dq.push_back(i);
    }
    std::cout << "[shrink_to_fit] 100个元素后 size = " << dq.size() << std::endl;

    // 删除大部分元素
    while (dq.size() > 5) dq.pop_back();
    std::cout << "[shrink_to_fit] 删除后 size = " << dq.size() << std::endl;

    dq.shrink_to_fit();
    std::cout << "[shrink_to_fit] shrink_to_fit 后 size = " << dq.size() << std::endl;
}

// 5.5 resize()
void demo_resize()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };

    // 扩大
    dq.resize(8, 99);
    std::cout << "[resize] 扩大到8（默认99）: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    // 缩小
    dq.resize(3);
    std::cout << "[resize] 缩小到3: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// ====================================================================

/*
* 6. 修改操作
*/

// 6.1 clear()
void demo_clear()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::cout << "[clear] 清楚前 size = " << dq.size() << std::endl;
    dq.clear();
    std::cout << "[clear] 清楚后 size = " << dq.size()
        << ", empty = " << dq.empty() << std::endl;
}

// 6.2 insert 单元素
void demo_insert_single()
{
    std::deque<int> dq = { 1, 2, 3 };
    auto it = dq.insert(dq.begin() + 2, 4); // 在索引2处插入4
    std::cout << "[insert单元素] 插入后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
    std::cout << "[insert单元素] 返回迭代器指向: " << *it << std::endl;
}

// 6.3 insert 填充
void demo_insert_fill()
{
    std::deque<int> dq = { 1, 2, 3 };
    dq.insert(dq.end(), 3, 88); // 在末尾插入3个88
    std::cout << "[insert填充] 插入后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.4 insert 范围
void demo_insert_range()
{
    std::deque<int> dq = { 1, 2, 7, 8 };
    std::vector<int> extra = { 3, 4, 5, 6 };
    dq.insert(dq.begin() + 2, extra.begin(), extra.end());
    std::cout << "[insert范围] 插入后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.5 insert 初始化列表
void demo_insert_initializer_list()
{
    std::deque<std::string> dq = { "a", "e" };
    dq.insert(dq.begin() + 1, { "b", "c", "d" });
    std::cout << "[insert初始化列表] 插入后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.6 emplace
void demo_emplace()
{
    std::deque<Student> students;
    students.emplace_back("Zara", 20, 91.0);
    students.emplace_back("Yuki", 22, 88.5);

    auto it = students.emplace(students.begin() + 1, "Xander", 21, 95.0);
    std::cout << "[emplace] 插入后: " << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
    std::cout << "[emplace] 返回迭代器指向: " << *it << std::endl;
}

// 6.7 erase 单元素
void demo_erase_single()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    auto it = dq.erase(dq.begin() + 2); // 删除索引2的元素(3)
    std::cout << "[erase单元素] 删除后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
    std::cout << "[erase单元素] 返回迭代器指向: " << *it << std::endl;
}

// 6.8 erase 范围
void deme_erase_range()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5, 6, 7, 8 };
    auto it = dq.erase(dq.begin() + 2, dq.begin() + 5); // 删除索引2~4
    std::cout << "[erase范围] 删除后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
    if (it != dq.end())
    {
        std::cout << "[erase范围] 返回迭代器指向: " << *it << std::endl;
    }
}

// 6.9 push_back
void demo_push_back()
{
    std::deque<int> dq;
    for (int i = 1; i <= 5; i++)
    {
        dq.push_back(i * 10);
    }
    std::cout << "[push_back] dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    // 自定义类型
    std::deque<Student> students;
    students.push_back(Student("Tom", 20, 85.0));
    students.push_back(Student("Jerry", 21, 90.0));
    std::cout << "[push_back-Student] size = " << students.size() << std::endl;
}

// 6.10 push_front
void demo_push_front()
{
    std::deque<int> dq = { 3, 4, 5 };
    dq.push_front(2);
    dq.push_front(1);
    std::cout << "[push_front] dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.11 emplace_back
void demo_emplace_back()
{
    std::deque<Student> students;
    students.emplace_back("Alice", 22, 95.5);
    students.emplace_back("Bob", 21, 88.0);
    students.emplace_back("Charlie", 23, 92.3);
    std::cout << "[emplace_back] students: " << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
}

// 6.12 emplace_front
void demo_emplace_front()
{
    std::deque<Student> students;
    students.emplace_back("Bob", 21, 88.0);
    students.emplace_front("Alice", 22, 95.0);  // 在头部原地构造
    std::cout << "[emplace_front] students: " << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
}

// 6.13 pop_back
void demo_pop_back()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::cout << "[pop_back] 弹出前: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    dq.pop_back();
    std::cout << "[pop_back] 弹出后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 6.14 pop_front
void demo_pop_front()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::cout << "[pop_front] 弹出前: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    dq.pop_front();
    std::cout << "[pop_front] 弹出后: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// ====================================================================

/*
* 7. swap 操作
*/

// 7.1 swap 成员函数
void demo_swap()
{
    std::deque<int> dq1 = { 1, 2, 3 };
    std::deque<int> dq2 = { 10, 20, 30, 40 };
    std::cout << "[swap] 交换前 dq1.size=" << dq1.size()
        << " dqw.size=" << dq2.size() << std::endl;

    dq1.swap(dq2);
    std::cout << "[swap] 交换后 dq1: ";
    for (const auto& val : dq1) std::cout << val << " ";
    std::cout << " | dq2: ";
    for (const auto& val : dq2) std::cout << val << " ";
    std::cout << std::endl;
}

// ====================================================================

/*
* 8. 非成员函数
*/

// 8.1 std::swap
void demo_std_swap()
{
    std::deque<int> a = { 1, 2, 3 };
    std::deque<int> b = { 4, 5, 6, 7 };
    std::swap(a, b);
    std::cout << "[std::swap] a: ";
    for (const auto& val : a) std::cout << val << " ";
    std::cout << " | b: ";
    for (const auto& val : b) std::cout << val << " ";
    std::cout << std::endl;
}

// 8.2 比较运算符
void demo_comparison_operators()
{
    std::deque<int> dq1 = { 1, 2, 3 };
    std::deque<int> dq2 = { 1, 2, 3 };
    std::deque<int> dq3 = { 1, 2, 4 };
    std::deque<int> dq4 = { 1, 2 };

    std::cout << "[==] dq1 == dq2: " << (dq1 == dq2) << std::endl;
    std::cout << "[!=] dq1 != dq3: " << (dq1 != dq3) << std::endl;
    std::cout << "[<] dq1 < dq3: " << (dq1 < dq3) << std::endl;
    std::cout << "[>] dq3 > dq1: " << (dq3 > dq1) << std::endl;
    std::cout << "[<=] dq1 <= dq2: " << (dq1 <= dq2) << std::endl;
    std::cout << "[>=] dq1 >= dq4: " << (dq1 >= dq4) << std::endl;
}

// 8.3 std::erase (C++ 20)
void demo_std_erase()
{
#if _MSVC_LANG >= 202002L
    std::deque<int> dq = { 1, 2, 3, 2, 4, 2, 5 };
    auto count = std::erase(dq, 2);
    std::cout << "[std::erase] 删除了 " << count << "个2, dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
#else
    std::deque<int> dq = { 1, 2, 3, 2, 4, 2, 5 };
    auto old_size = dq.size();
    dq.erase(std::remove(dq.begin(), dq.end(), 2), dq.end());
    auto count = old_size - dq.size();
    std::cout << "[erase-remove惯用法] 删除了 " << count << "个2, dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
#endif
}

// 8.4 std::erase_if (C++ 20)
void demo_std_erase_if()
{
#if _MSVC_LANG >= 202002L
    std::deque<int> dq = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    auto count = std::erase_if(dq, [](int x) {return x % 2 == 0; });
    std::cout << "[std::erase_if] 删除了 " << count << " 个偶数, dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
#else
    std::deque<int> dq = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    auto old_size = dq.size();
    dq.erase(std::remove_if(dq.begin(), dq.end(), [](int x) {return x % 2 == 0; }), dq.end());
    auto count = old_size - dq.size();
    std::cout << "[erase-remove_if惯用法] 删除了 " << count << " 个偶数, dq: ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
#endif
}

// ====================================================================

/*
* 9. 遍历方式
*/

// 9.1 范围for遍历
void demo_range_for()
{
    std::deque<int> dq = { 10, 20, 30, 40, 50 };
    std::cout << "[范围for-只读] ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    std::cout << "[范围for-修改] ";
    for (auto& val : dq)
    {
        val += 1;
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

// 9.2 迭代器遍历
void demo_iterator_traversal()
{
    std::deque<Student> students = {
        Student("Alice", 22, 95.5),
        Student("Bob", 21, 88.0),
        Student("Charlie", 23, 92.3)
    };
    std::cout << "[迭代器遍历] " << std::endl;
    for (auto it = students.begin(); it != students.end(); it++)
    {
        std::cout << "  " << *it << std::endl;
    }
}

// 9.3 下标遍历
void demo_index_traversal()
{
    std::deque<int> dq = { 100, 200, 300, 400, 500 };
    std::cout << "[下标遍历] ";
    for (size_t i = 0; i < dq.size(); i++)
    {
        std::cout << "dq[" << i << "]=" << dq[i] << " ";
    }
    std::cout << std::endl;
}

// 9.4 反向迭代器遍历
void demo_reverse_traversal()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::cout << "[反向遍历] ";
    for (auto it = dq.rbegin(); it != dq.rend(); it++)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

// ====================================================================

/*
* 10. 与算法配合
*/

// 10.1 sort
void demo_sort()
{
    std::deque<int> dq = { 5, 3, 1, 4, 2 };
    std::sort(dq.begin(), dq.end());
    std::cout << "[sort升序] ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    std::sort(dq.begin(), dq.end(), std::greater<int>());
    std::cout << "[sort降序] ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;

    // 自定义排序
    std::deque<Student> students = {
        Student("Alice", 22, 82.0),
        Student("Bob", 21, 95.0),
        Student("Charlie", 23, 90.0)
    };
    std::sort(students.begin(), students.end(),
        [](const Student& a, const Student& b) {return a.getScore() > b.getScore(); }
    );
    std::cout << "[sort-按分数排序] " << std::endl;
    for (const auto& s : students) std::cout << "  " << s << std::endl;
}

// 10.2 find
void demo_find()
{
    std::deque<int> dq = { 10, 20, 30, 40, 50 };
    auto it = std::find(dq.begin(), dq.end(), 30);
    if (it != dq.end())
    {
        std::cout << "[find] 找到30, 位置索引: " << (it - dq.begin()) << std::endl;
    }

    auto it2 = std::find(dq.begin(), dq.end(), 99);
    std::cout << "[find] 99: " << (it2 == dq.end() ? "未找到" : "找到") << std::endl;

    // find_if
    auto it3 = std::find_if(dq.begin(), dq.end(), [](int x) {return x > 25; });
    if (it3 != dq.end())
    {
        std::cout << "[find_if] 第一个>25的元素: " << *it3 << std::endl;
    }
}

// 10.3 count / count_if
void demo_count()
{
    std::deque<int> dq = { 1, 2, 2, 3, 2, 4, 2, 5 };
    auto cnt = std::count(dq.begin(), dq.end(), 2);
    std::cout << "[count] 2出现次数: " << cnt << std::endl;

    auto cnt2 = std::count_if(dq.begin(), dq.end(), [](int x) {return x > 2; });
    std::cout << "[count_if] >2的元素个数: " << cnt2 << std::endl;
}

// 10.4 accumulate
void demo_accumulate()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    int sum = std::accumulate(dq.begin(), dq.end(), 0);
    std::cout << "[accumulate] 求和: " << sum << std::endl;

    int product = std::accumulate(dq.begin(), dq.end(), 1, std::multiplies<int>());
    std::cout << "[accumulate] 求积: " << product << std::endl;
}

// 10.5 copy
void demo_copy_algo()
{
    std::deque<int> src = { 1, 2, 3, 4, 5 };
    std::deque<int> dst(src.size());
    std::copy(src.begin(), src.end(), dst.begin());
    std::cout << "[copy] dst: ";
    for (const auto& val : dst) std::cout << val << " ";
    std::cout << std::endl;
}

// 10.6 reverse
void demo_reverse()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::reverse(dq.begin(), dq.end());
    std::cout << "[reverse] ";
    for (const auto& val : dq) std::cout << val << " ";
    std::cout << std::endl;
}

// 10.7 transform
void demo_transform()
{
    std::deque<int> dq = { 1, 2, 3, 4, 5 };
    std::deque<int> result(dq.size());
    std::transform(dq.begin(), dq.end(), result.begin(), [](int x) { return x * x; });
    std::cout << "[transform-平方] ";
    for (const auto& val : result) std::cout << val << " ";
    std::cout << std::endl;
}

// 10.8 for_each
void demo_for_each()
{
    std::deque<Student> students = {
        Student("Alice", 22, 95.5),
        Student("Bob", 21, 88.0),
        Student("Charlie", 23, 92.3)
    };
    std::cout << "[for_each] " << std::endl;
    std::for_each(students.begin(), students.end(),
        [](const Student& s) {std::cout << " " << s.getName() << "-" << s.getScore() << std::endl; }
    );
}

// 10.9 any_of / all_of / none_of
void demo_predicates()
{
    std::deque<int> dq = { 2, 4, 6, 8, 10 };
    std::cout << "[all_of] 全部偶数: "
        << std::all_of(dq.begin(), dq.end(), [](int x) {return x % 2 == 0; })
        << std::endl;
    std::cout << "[any_of] 存在>5: "
        << std::any_of(dq.begin(), dq.end(), [](int x) {return x > 5; })
        << std::endl;
    std::cout << "[none_if] 无负数: "
        << std::none_of(dq.begin(), dq.end(), [](int x) {return x < 0; })
        << std::endl;
}

// ====================================================================

/*
* 11. 实战场景
*/

// 11.1 模拟滑动窗口
void demo_sliding_window()
{
    std::deque<int> window;
    std::deque<int> data = { 1, 3, -1, -3, 5, 3, 6, 7 };
    int k = 3;

    std::cout << "[滑动窗口] 窗口大小=" << k << ", 数据: ";
    for (int val : data) std::cout << val << " ";
    std::cout << std::endl;

    std::deque<int> indices;    // 存储索引的双端队列
    std::vector<int> max_values;

    for (int i = 0; i < static_cast<int>(data.size()); i++)
    {
        while (!indices.empty() && indices.front() <= i - k)
        {
            indices.pop_front();
        }
        while (!indices.empty() && data[indices.back()] <= data[i])
        {
            indices.pop_back();
        }
        indices.push_back(i);

        if (i >= k - 1)
        {
            max_values.push_back(data[indices.front()]);
        }
    }

    std::cout << "[滑动窗口] 每个窗口最大值: ";
    for (int val : max_values) std::cout << val << " ";
    std::cout << std::endl;
}

// 11.2 消息队列
void demo_message_queue()
{
    std::deque<Task> taskQueue;

    // 尾部添加普通任务
    taskQueue.emplace_back(1, "写报告", 1);
    taskQueue.emplace_back(2, "发邮件", 1);
    taskQueue.emplace_back(3, "开会", 2);

    // 头部插入紧急任务
    taskQueue.emplace_front(4, "紧急修复Bug", 10);

    std::cout << "[消息队列] 任务列表: " << std::endl;
    while (!taskQueue.empty())
    {
        std::cout << "  处理: " << taskQueue.front() << std::endl;
        taskQueue.pop_front();
    }
}

// 11.3 实现回文检测
void demo_palindrome_check()
{
    std::deque<char> dq;
    std::string text = "racecar";
    for (char c : text)
    {
        dq.push_back(c);
    }

    bool isPalindrome = true;
    while (dq.size() > 1)
    {
        if (dq.front() != dq.back())
        {
            isPalindrome = false;
            break;
        }
        dq.pop_front();
        dq.pop_back();
    }

    std::cout << "[回文检测] \"" << text << "\" 是回文: "
        << (isPalindrome ? "是" : "否") << std::endl;
}

// 11.4 双端缓冲区
void demo_double_ended_buffer()
{
    std::deque<int> buffer;
    const size_t MAX_SIZE = 5;

    // 尾部追加新数据，超过容量则从头部移除旧数据
    auto addToBuffer = [&](int val) {
        if (buffer.size() >= MAX_SIZE)
        {
            buffer.pop_front();
        }
        buffer.push_back(val);
    };

    for (int i = 1; i <= 8; i++)
    {
        addToBuffer(i * 10);
        std::cout << "[缓冲区] 添加" << i * 10 << "后: ";
        for (const auto& v : buffer) std::cout << v << " ";
        std::cout << std::endl;
    }
}

// ====================================================================

int main()
{
    std::cout << "========== 1. 构造函数 ==========" << std::endl;
    demo_default_constructor();
    demo_fill_constructor();
    demo_range_constructor();
    demo_copy_constructor();
    demo_initializer_list_constructor();

    std::cout << "\n========== 2. 赋值操作 ==========" << std::endl;
    demo_copy_assignment();
    demo_move_assignment();
    demo_initializer_list_assignment();
    demo_assign_fill();
    demo_assign_range();
    demo_assign_initializer_list();

    std::cout << "\n========== 3. 元素访问 ==========" << std::endl;
    demo_at();
    demo_operator_bracket();
    demo_front();
    demo_back();

    std::cout << "\n========== 4. 迭代器 ==========" << std::endl;
    demo_begin_end();
    demo_cbegin_cend();
    demo_rbegin_rend();
    demo_crbegin_crend();

    std::cout << "\n========== 5. 容量相关 ==========" << std::endl;
    demo_empty();
    demo_size();
    demo_max_size();
    demo_shrink_to_fit();
    demo_resize();

    std::cout << "\n========== 6. 修改操作 ==========" << std::endl;
    demo_insert_single();
    demo_insert_fill();
    demo_insert_range();
    demo_insert_initializer_list();
    demo_emplace();
    demo_erase_single();
    deme_erase_range();
    demo_push_back();
    demo_push_front();
    demo_emplace_back();
    demo_emplace_front();
    demo_pop_back();
    demo_pop_front();

    std::cout << "\n========== 7. swap ==========" << std::endl;
    demo_swap();

    std::cout << "\n========== 8. 非成员函数 ==========" << std::endl;
    demo_std_swap();
    demo_comparison_operators();
    demo_std_erase();
    demo_std_erase_if();

    std::cout << "\n========== 9. 遍历方式 ==========" << std::endl;
    demo_range_for();
    demo_iterator_traversal();
    demo_index_traversal();
    demo_reverse_traversal();

    std::cout << "\n========== 10. 与算法配合 ==========" << std::endl;
    demo_sort();
    demo_find();
    demo_count();
    demo_accumulate();
    demo_copy_algo();
    demo_reverse();
    demo_transform();
    demo_for_each();
    demo_predicates();

    std::cout << "\n========== 10. 与算法配合 ==========" << std::endl;
    demo_sliding_window();
    demo_message_queue();
    demo_palindrome_check();
    demo_double_ended_buffer();

    return 0;
}
相关推荐
QN1幻化引擎5 小时前
Gravity-Anchored Cognitive Field Architecture: The DalinX V8/V10 Implementation
java·前端·算法
吃着火锅x唱着歌5 小时前
Effective C++ 学习笔记 条款33 避免遮掩继承来的名称
c++·笔记·学习
学计算机的计算基5 小时前
LeetCode 图论四题精讲：BFS、拓扑排序、Trie 树的模板与优化
java·笔记·算法
浩瀚地学5 小时前
【面试算法笔记】0202-链表-基本功能实现
java·经验分享·笔记·算法·面试
你想知道什么?5 小时前
Matplotlib学习笔记
笔记·学习·matplotlib
tkevinjd5 小时前
416分割等和子集
java·python·算法·leetcode·职场和发展
Keven_116 小时前
算法札记：Tarjan与拓扑序（Topo）的关系
算法·拓扑·tarjan
库克克6 小时前
【C++】类和对象--类对象模型与大小计算
开发语言·jvm·c++
AOwhisky6 小时前
Linux（CentOS）系统管理入门笔记：第二期核心知识点自测与详解
linux·笔记·centos
ShallWeL6 小时前
AUC、F1、召回率怎么选
人工智能·算法·机器学习
热门推荐
01GitHub 镜像站点02AI科技热点日报 | 2026年07月01日032026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片04幻兽帕鲁 - 服务器管理员权限与 GM 命令完全指南05GPT-5.5 对比 GPT-5.6 Sol、Terra、Luna：官方性能数据与选型分析062026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？07AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路082026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf092026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？102026 年 AI 大模型 & AI 编程工具实战全总结