3. max_size()
max_size() 是 std::list 容器的一个成员函数，用于返回容器可能容纳的最大元素数量，通常受到系统内存限制的影响。它返回一个无符号整数类型，表示容器的最大大小。函数签名如下：
size_type max_size() const noexcept;
返回值：返回容器可能容纳的最大元素数量。
使用示例：
#include <iostream> #include <list> int main() { std::list<int> myList; std::cout << "Max size of the list: " << myList.max_size() << std::endl; return 0; }
在上面的示例中，我们创建了一个空的 std::list 容器 myList，然后使用 max_size() 函数获取容器的最大大小，并输出到标准输出。请注意，实际可用的最大大小取决于系统内存和其他资源的限制。
4. front()
front() 是 std::list 容器的成员函数，用于返回容器中第一个元素的引用。这个函数有两个版本，一个用于可修改容器的对象，另一个用于只读（const）容器的对象。函数的签名如下：
reference front();
const_reference front() const;
reference：返回一个对容器中第一个元素的非常引用。
const_reference：只有在 const 容器对象上调用时，才返回一个对容器中第一个元素的常引用。
使用示例：
#include <iostream> #include <list> int main() { std::list<int> myList = {10, 20, 30}; int& firstElement = myList.front(); const int& constFirstElement = myList.front(); std::cout << "First element: " << firstElement << std::endl; std::cout << "Const first element: " << constFirstElement << std::endl; return 0; }
在上面的示例中，我们创建了一个 std::list 容器 myList，其中包含三个整数元素。我们使用 front() 函数来获取容器中的第一个元素的引用，分别存储为可修改的引用 firstElement 和只读的常引用 constFirstElement，然后将它们输出到标准输出。
5. back()
back() 是 std::list 容器的成员函数，用于返回容器中最后一个元素的引用。这个函数有两个版本，一个用于可修改容器的对象，另一个用于只读（const）容器的对象。函数的签名如下：
reference back();
const_reference back() const;
reference：返回一个对容器中最后一个元素的非常引用。
const_reference：只有在 const 容器对象上调用时，才返回一个对容器中最后一个元素的常引用。
使用示例：
#include <iostream> #include <list> int main() { std::list<int> myList = {10, 20, 30}; int& lastElement = myList.back(); const int& constLastElement = myList.back(); std::cout << "Last element: " << lastElement << std::endl; std::cout << "Const last element: " << constLastElement << std::endl; return 0; }
在上面的示例中，我们创建了一个 std::list 容器 myList，其中包含三个整数元素。我们使用 back() 函数来获取容器中的最后一个元素的引用，分别存储为可修改的引用 lastElement 和只读的常引用 constLastElement，然后将它们输出到标准输出。
list增删查改函数(Modifiers)
1. assign
assign 是 std::list 容器的成员函数，用于将容器的内容替换为新的元素。这个函数有三个不同版本：
使用迭代器范围：
template <class InputIterator>
void assign (InputIterator first, InputIterator last);
这个版本接受两个迭代器参数 first 和 last，用来指定一个范围。它会将容器的内容替换为范围 [first, last) 内的元素。
使用重复元素：
void assign (size_type n, const value_type& val);
这个版本接受一个整数参数 n，和一个值 val。它会将容器的内容替换为 n 个值为 val 的元素。
使用初始化列表：
void assign (initializer_list<value_type> il);
这个版本接受一个初始化列表作为参数。它会将容器的内容替换为初始化列表中的元素。
使用示例：
#include <iostream> #include <list> int main() { std::list<int> myList; myList.assign({1, 2, 3, 4, 5}); // 使用初始化列表 std::cout << "Size after assigning with initializer list: " << myList.size() << std::endl; myList.assign(3, 100); // 使用重复元素 std::cout << "Size after assigning with repeated elements: " << myList.size() << std::endl; std::list<int> anotherList = {10, 20, 30, 40}; myList.assign(anotherList.begin(), anotherList.end()); // 使用迭代器范围 std::cout << "Size after assigning with iterator range: " << myList.size() << std::endl; return 0; }
在上面的示例中，我们首先创建了一个空的 std::list 容器 myList。然后使用不同版本的 assign 函数来分别替换容器的内容。最后，我们输出容器的大小以验证操作是否成功。
2. emplace_front
template <class... Args>
void emplace_front (Args&&... args);
emplace_front 是 std::list 容器的成员函数，用于在容器的开头插入一个新元素。它通过在指定位置直接构造元素，避免了额外的拷贝或移动操作。
这个函数接受可变数量的参数 Args...，这些参数会被用来构造新元素。使用 emplace_front 可以直接在容器的开头插入元素，而不需要先创建一个临时对象然后再进行插入操作。
使用示例：
#include <iostream> #include <list> struct Person { std::string name; int age; Person(const std::string& n, int a) : name(n), age(a) { std::cout << "Constructing " << name << std::endl; } }; int main() { std::list<Person> personList; personList.emplace_front("zhangsan", 25); personList.emplace_front("lisi", 30); personList.emplace_front("wangwu", 28); std::cout << "Person list contents:" << std::endl; for (const auto& person : personList) { std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl; } return 0; }
在上述示例中，我们首先定义了一个名为 Person 的结构体，它有两个成员变量：name 和 age。然后我们创建了一个空的 std::list 容器 personList，使用 emplace_front 函数分别在容器的开头插入了几个新的 Person 对象，直接在插入位置进行构造。
注意，emplace_front 的参数被传递给 Person 类型的构造函数，用于构造新的 Person 对象。这样做避免了额外的拷贝或移动操作，提高了效率。
3. push_front
push_front 是 std::list 容器的成员函数，用于在容器的开头插入一个新元素。
这个函数有两个版本：
void push_front (const value_type& val);：接受一个常量引用参数，会创建一个新元素并将参数的值拷贝到新元素中。
void push_front (value_type&& val);：接受一个右值引用参数，用于移动构造一个新元素。这样可以避免额外的拷贝操作，提高了效率。
使用示例：
#include <iostream> #include <list> int main() { std::list<int> myList; int value = 20; myList.push_front(value); // Copy insert std::cout << "List contents:" << std::endl; for (const auto& num : myList) { std::cout << num << " "; } std::cout << std::endl; myList.push_front(25); // Move insert std::cout << "List contents after move insert:" << std::endl; for (const auto& num : myList) { std::cout << num << " "; } std::cout << std::endl; return 0; }
在上述示例中，我们首先创建一个空的 std::list 容器 myList，然后使用 push_front 函数分别进行了常量引用拷贝插入和右值引用移动插入操作。可以看到，右值引用版本的 push_front 更加高效，因为它避免了额外的拷贝操作。
4. pop_front
void pop_front(); 是用于从 std::list 的开头移除一个元素的成员函数。它会删除列表中的第一个元素，并且将列表的大小减小一个单位。
示例用法：
std::list<int> myList = {1, 2, 3, 4, 5}; myList.pop_front(); // 移除第一个元素
在上面的例子中，pop_front() 将会移除 1 这个元素，使得列表变为 {2, 3, 4, 5}。
5. emplace_back
template <class... Args> void emplace_back (Args&&... args); 是一个用于在 std::list 的末尾插入新元素的函数。它允许你通过传递构造元素所需的参数来直接在列表的末尾构造元素，避免了额外的拷贝或移动操作。
示例用法：
std::list<std::string> myList; myList.emplace_back("Hello"); myList.emplace_back("World");
在上面的例子中，emplace_back 函数直接在列表的末尾构造了两个字符串元素，分别是 "Hello" 和 "World"。
这个函数对于避免额外的元素构造和拷贝操作很有用，特别是在容器中存储大型对象时，可以提高性能。
6. push_back
void push_back (const value_type& val); 是 std::list 容器的成员函数，用于在列表的末尾插入一个新元素。它接受一个常量引用作为参数，将传入的值插入到列表末尾。
示例用法：
std::list<int> myList; myList.push_back(10); myList.push_back(20); myList.push_back(30);
在上面的例子中，push_back 函数分别将整数 10、20 和 30 插入到列表的末尾。
这个函数在操作上相对简单，但是可能涉及到内存分配和元素拷贝操作。如果插入的元素比较大，可能会导致额外的性能开销。
7. pop_back
void pop_back(); 是 std::list 容器的成员函数，用于删除列表中的最后一个元素。它会将列表的最后一个元素从容器中移除，同时释放相应的内存资源。
示例用法：
std::list<int> myList; myList.push_back(10); myList.push_back(20); myList.push_back(30); myList.pop_back();
在上面的例子中，pop_back 函数会移除列表中的元素 30，使列表变为 [10, 20]。
需要注意的是，调用 pop_back 函数前需要确保列表不为空，否则会出现未定义的行为。可以通过 empty() 函数来判断列表是否为空。
8. emplace
template <class... Args> iterator emplace (const_iterator position, Args&&... args); 是 std::list 容器的成员函数，用于在指定位置插入一个新元素，并将元素构造函数的参数传递给插入的元素。
参数说明：
position：要插入新元素的位置的迭代器。
args：传递给新元素构造函数的参数。
该函数返回一个迭代器，指向新插入的元素。
示例用法：
std::list<int> myList = {10, 20, 30}; auto it = myList.begin(); ++it; // 移动到第二个元素的位置 myList.emplace(it, 25); // 在第二个元素位置插入值为 25 的元素
在上面的例子中，emplace 函数在第二个元素的位置插入了一个值为 25 的新元素，使列表变为 [10, 25, 20, 30]。返回的迭代器指向插入的元素 25。
这个函数适用于在任意位置插入元素，并且可以通过参数直接传递给元素的构造函数。
9. insert
iterator insert (iterator position, const value_type& val);
void insert (iterator position, size_type n, const value_type& val);
template <class InputIterator>
void insert (iterator position, InputIterator first, InputIterator last);
iterator insert (iterator position, const value_type& val); 是 std::list 容器的成员函数，用于在指定位置插入一个新元素，新元素的值由 val 参数确定。
参数说明：
position：要插入新元素的位置的迭代器。
val：要插入的元素的值。
该函数返回一个迭代器，指向插入的元素。
示例用法：
std::list<int> myList = {10, 20, 30}; auto it = myList.begin(); ++it; // 移动到第二个元素的位置 myList.insert(it, 25); // 在第二个元素位置插入值为 25 的元素
void insert (iterator position, size_type n, const value_type& val); 是另一个版本的插入函数，可以插入指定数量的相同值的元素。
参数说明：
position：要插入新元素的位置的迭代器。
n：要插入的相同元素的数量。
val：要插入的元素的值。
template <class InputIterator> void insert (iterator position, InputIterator first, InputIterator last); 是另一个版本的插入函数，可以从指定范围的迭代器中插入一系列元素。
参数说明：
position：要插入新元素的位置的迭代器。
first 和 last：要插入的元素范围的迭代器。
这些 insert 函数提供了不同的插入方式，使你可以根据需要灵活地向列表中添加元素。
10. erase
iterator erase (iterator position); 和 iterator erase (iterator first, iterator last); 是 std::list 容器的成员函数，用于从列表中删除一个或多个元素。
iterator erase (iterator position); 删除指定位置的元素，并返回指向下一个元素的迭代器。
参数说明：
position：要删除的元素的位置的迭代器。
返回值：指向被删除元素之后的元素的迭代器。
示例用法：
std::list<int> myList = {10, 20, 30, 40}; auto it = myList.begin(); ++it; // 移动到第二个元素的位置 myList.erase(it); // 删除第二个元素
iterator erase (iterator first, iterator last); 删除指定范围内的元素，并返回指向被删除范围之后的元素的迭代器。
参数说明：
first 和 last：要删除的元素范围的迭代器，删除的范围包括 first，但不包括 last。
返回值：指向被删除范围之后的元素的迭代器。
示例用法：
std::list<int> myList = {10, 20, 30, 40}; auto it1 = myList.begin(); auto it2 = myList.begin(); std::advance(it2, 2); // 移动到第三个元素的位置 myList.erase(it1, it2); // 删除第一个和第二个元素
这些函数允许你根据需要从列表中删除一个或多个元素，并返回正确的迭代器以便进行后续操作。
