在 C++ 里，`<list>` 标准库提供了双向链表容器 `std::list`。双向链表是一种由节点构成的数据结构，每个节点都存有数据和分别指向前后节点的指针。下面会详细总结 `std::list` 的用法。

### 1. 头文件包含
要使用 `std::list`，得包含 `<list>` 头文件。
```cpp
#include <list>
```

### 2. 定义与初始化
可以用以下方式定义并初始化 `std::list`：
```cpp
#include <iostream>
#include <list>

int main() {
    // 定义一个存储整数的空列表
    std::list<int> myList1;

    // 定义一个包含 5 个值为 10 的元素的列表
    std::list<int> myList2(5, 10);

    // 用初始化列表初始化列表
    std::list<int> myList3 = {1, 2, 3, 4, 5};

    // 用另一个列表初始化新列表
    std::list<int> myList4(myList3);

    return 0;
}
```

### 3. 常用成员函数

#### 3.1 元素访问
- **`front()`**：返回列表首个元素的引用。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3};
    std::cout << "First element: " << myList.front() << std::endl;
    return 0;
}
```
- **`back()`**：返回列表最后一个元素的引用。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3};
    std::cout << "Last element: " << myList.back() << std::endl;
    return 0;
}
```

#### 3.2 容量操作
- **`empty()`**：判断列表是否为空，若为空则返回 `true`，反之返回 `false`。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList;
    std::cout << "Is list empty? " << (myList.empty() ? "Yes" : "No") << std::endl;
    return 0;
}
```
- **`size()`**：返回列表中元素的数量。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3};
    std::cout << "List size: " << myList.size() << std::endl;
    return 0;
}
```

#### 3.3 修改操作
- **`push_front()`**：在列表头部插入元素。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {2, 3};
    myList.push_front(1);
    for (int num : myList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}
```
- **`push_back()`**：在列表尾部插入元素。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2};
    myList.push_back(3);
    for (int num : myList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}
```
- **`pop_front()`**：移除列表头部的元素。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3};
    myList.pop_front();
    for (int num : myList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}
```
- **`pop_back()`**：移除列表尾部的元素。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3};
    myList.pop_back();
    for (int num : myList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}
```
- **`insert()`**：在指定位置插入元素。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 3};
    auto it = ++myList.begin();
    myList.insert(it, 2);
    for (int num : myList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}
```
- **`erase()`**：移除指定位置或指定范围的元素。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};
    auto it = ++myList.begin();
    myList.erase(it);
    for (int num : myList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}
```
- **`clear()`**：清空列表中的所有元素。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3};
    myList.clear();
    std::cout << "List size after clear: " << myList.size() << std::endl;
    return 0;
}
```

#### 3.4 其他操作
- **`sort()`**：对列表中的元素进行排序。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {3, 1, 2};
    myList.sort();
    for (int num : myList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}
```
- **`reverse()`**：反转列表中元素的顺序。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3};
    myList.reverse();
    for (int num : myList) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    return 0;
}
```

### 4. 迭代器
`std::list` 支持双向迭代器，你可以用迭代器遍历列表。
```cpp
#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};

    // 正向遍历
    for (auto it = myList.begin(); it != myList.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 反向遍历
    for (auto it = myList.rbegin(); it != myList.rend(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}
```

### 5. 优缺点

#### 优点
- 插入和删除操作效率高，时间复杂度为 $O(1)$。
- 支持双向访问。

#### 缺点
- 随机访问效率低，不支持 `[]` 操作符和 `at()` 函数。
- 相比于数组，占用更多的内存空间，因为每个节点都需要额外的指针。

### 6. 应用场景
- 适用于需要频繁插入和删除元素的场景，如实现栈、队列等数据结构。
- 当不需要随机访问元素时，可以使用 `std::list` 来提高插入和删除操作的效率。

通过上述介绍，你可以掌握 C++ 中 `std::list` 标准库的基本用法。 