1. **构造函数**：
   - `list()`：创建一个空链表。
   - `list(const list& other)`：拷贝构造函数，用另一个链表初始化当前链表。

2. **赋值和交换**：
   - `operator=`：将一个链表赋值给另一个链表。
   - `assign`：用特定数量的元素或范围内的元素替换链表的内容。
   - `swap`：交换两个链表的内容。

3. **迭代器相关**：
   - `begin`：返回指向第一个元素的迭代器。
   - `end`：返回指向最后一个元素之后的位置的迭代器。
   - `rbegin`：返回指向最后一个元素的反向迭代器。
   - `rend`：返回指向第一个元素之前的位置的反向迭代器。

4. **容量**：
   - `empty`：判断链表是否为空。
   - `size`：返回链表中元素的数量。
   - `max_size`：返回链表最大可容纳的元素数量。

5. **访问元素**：
   - `front`：返回第一个元素的引用。
   - `back`：返回最后一个元素的引用。

6. **修改容器**：
   - `push_front`：在链表的开头插入一个元素。
   - `pop_front`：移除链表的第一个元素。
   - `push_back`：在链表的末尾插入一个元素。
   - `pop_back`：移除链表的最后一个元素。
   - `insert`：在指定位置插入一个或多个元素。
   - `erase`：移除指定位置或范围内的一个或多个元素。
   - `clear`：移除链表的所有元素。

7. **其他操作**：
   - `splice`：将另一个链表的元素移动到当前链表的指定位置。
   - `merge`：将两个有序链表合并为一个有序链表。
   - `sort`：对链表进行排序。
   - `reverse`：反转链表中的元素顺序。



1. **构造函数**：
   
   ```cpp
   #include <iostream>
   #include <list>
   using namespace std;
   
   int main() {
       // 创建空链表
       list<int> mylist;
   
       // 用另一个链表初始化当前链表
       list<int> otherlist = {1, 2, 3};
       list<int> mylist2(otherlist);
   
       return 0;
   }
   ```
   
2. **赋值和交换**：
   
   ```cpp
   // 赋值
   mylist = otherlist;
   
   // 用特定数量的元素或范围内的元素替换链表的内容
   mylist.assign(5, 10);  // 用5个值为10的元素替换mylist的内容
   
   // 交换两个链表的内容
   mylist.swap(otherlist);
   ```
   
3. **迭代器相关**：
   ```cpp
   // 使用迭代器访问元素
   list<int>::iterator it = mylist.begin();
   for (; it != mylist.end(); ++it) {
       cout << *it << " ";
   }
   ```

4. **容量**：
   ```cpp
   // 判断链表是否为空
   if (mylist.empty()) {
       cout << "链表为空" << endl;
   }
   
   // 返回链表中元素的数量
   cout << "链表中元素的数量：" << mylist.size() << endl;
   ```

5. **访问元素**：
   ```cpp
   // 返回第一个元素的引用
   int firstElement = mylist.front();
   
   // 返回最后一个元素的引用
   int lastElement = mylist.back();
   ```

6. **修改容器**：
   ```cpp
   // 在链表的开头插入一个元素
   mylist.push_front(100);
   
   // 移除链表的第一个元素
   mylist.pop_front();
   
   // 在链表的末尾插入一个元素
   mylist.push_back(200);
   
   // 移除链表的最后一个元素
   mylist.pop_back();
   
   // 在指定位置插入一个或多个元素
   list<int>::iterator it = mylist.begin();
   advance(it, 2);  // 移动迭代器到第三个位置
   mylist.insert(it, 777);
   
   // 移除指定位置或范围内的一个或多个元素
   it = mylist.begin();
   advance(it, 1);  // 移动迭代器到第二个位置
   mylist.erase(it);
   
   // 移除链表的所有元素
   mylist.clear();
   ```

7. **其他操作**：
   ```cpp
   // 将另一个链表的元素移动到当前链表的指定位置
   list<int> anotherlist = {9, 8, 7};
   list<int>::iterator pos = mylist.begin();
   advance(pos, 2);  // 移动到第三个位置
   mylist.splice(pos, anotherlist);
   
   // 将两个有序链表合并为一个有序链表
   list<int> sortedlist1 = {1, 3, 5};
   list<int> sortedlist2 = {2, 4, 6};
   sortedlist1.merge(sortedlist2);
   
   // 对链表进行排序
   mylist.sort();
   
   // 反转链表中的元素顺序
   mylist.reverse();
   ```

