长沙网站seo费用,广州网站建设乐云seo模板中心,网站搭建网,济南网络推广公司排名list#xff08;理解和使用#xff09; 什么是list特点和优势基本操作示例用法与其他序列式容器#xff08;如 std::vector 和 std::deque#xff09;相比#xff0c;std::list 显著的区别和优势成员类型 list构造函数1. default (1)2. fill (2)3.range (3)4. copy (4) li… list理解和使用 什么是list特点和优势基本操作示例用法与其他序列式容器如 std::vector 和 std::deque相比std::list 显著的区别和优势成员类型 list构造函数1. default (1)2. fill (2)3.range (3)4. copy (4) list迭代器Iterators1. begin()2. end()3. rbegin()4. rend()5. cbegin()、cend()、crbegin()、crend() list容量函数(Capacity)和元素访问函数(Element access)1. empty()2. size()3. max_size()4. front()5. back() list增删查改函数(Modifiers)1. assign2. emplace_front3. push_front4. pop_front5. emplace_back6. push_back7. pop_back8. emplace9. insert10. erase11. swap12. resize13. clear list操作函数(Operations)1. splice2. remove3. remove_if4. unique5. merge6. sort7. reverse list的迭代器失效结语 什么是list 在C标准库中std::list 是一个双向链表容器用于存储一系列元素。与 std::vector 和 std::deque 等容器不同std::list 使用链表的数据结构来组织元素因此在某些操作上具有独特的优势和性能特点。以下是关于 std::list 的详细介绍
特点和优势 双向链表结构 std::list 内部使用双向链表来存储元素。这意味着在插入和删除元素时不会引起其他元素的内存重新分配和复制因此在这些操作上具有常数时间复杂度。 插入和删除操作效率高 由于链表结构插入和删除元素的操作效率非常高。对于大量的插入和删除操作std::list 往往比其他容器更具优势。 迭代器的稳定性 在 std::list 中插入和删除元素不会使迭代器失效除非删除的正是迭代器所指向的元素。这使得在遍历过程中进行插入和删除操作更加方便和安全。 空间占用 std::list每个元素都需要存储一个指向前后元素的指针因此相对于数组型的容器std::list 的空间占用会更高。 基本操作 push_back() 和 push_front(): 在链表的末尾和开头插入元素。 pop_back() 和 pop_front(): 删除链表的末尾和开头的元素。 insert(): 在指定位置插入元素。 erase(): 删除指定位置的元素。 begin() 和 end(): 返回指向链表起始元素和尾部元素后一个位置的迭代器。 size(): 返回链表中的元素数量。 empty(): 检查链表是否为空。 clear(): 清空链表中的所有元素。 示例用法
#include iostream
#include listint main() {std::listint myList;myList.push_back(1);myList.push_back(2);myList.push_back(3);myList.pop_front();myList.insert(std::next(myList.begin()), 4);for (const auto num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在使用 std::list 时需要权衡其优势和劣势根据实际场景来选择合适的容器。当需要频繁插入和删除元素且不需要随机访问时std::list 可能是一个很好的选择。但需要注意的是由于链表的特性std::list 并不适用于需要快速随机访问元素的场景因为访问某个位置的元素需要遍历链表。
与其他序列式容器如 std::vector 和 std::deque相比std::list 显著的区别和优势
优势 插入和删除效率高 由于 std::list 是双向链表插入和删除操作在常数时间内完成不需要涉及内存的重新分配和元素的复制。这使得 std::list 在大量插入和删除操作时非常高效。 迭代器的稳定性 std::list 的插入和删除操作不会使迭代器失效除非删除的正是迭代器所指向的元素。这使得在遍历过程中进行插入和删除操作更加方便和安全。 空间占用相对稳定 std::list 的空间占用相对稳定插入和删除操作不会影响其他元素的空间占用。 劣势 不支持随机访问 由于链表的结构std::list 不支持像数组一样的随机访问。访问某个位置的元素需要从链表的开头或结尾开始遍历。 额外的指针开销 std::list 中的每个元素都需要存储指向前后元素的指针这使得空间占用相对其他容器更高。 缓存效率低 由于链表中元素在内存中的存储位置不连续导致在访问链表元素时缓存命中率较低可能影响性能。 迭代器的使用限制 std::list 的迭代器不支持与普通指针类似的算术操作如 和 -因此无法像 std::vector 那样灵活地进行迭代器操作。 成员类型 list构造函数 当使用 std::list 类创建对象时可以使用不同的构造函数来满足不同的初始化需求。下面详细介绍每个构造函数及其使用示例
1. default (1)
这个构造函数用于创建一个空的 std::list 容器。它可以接受一个可选的分配器参数用于指定内存分配策略。
std::listint myList; // 创建一个空的 std::list 容器2. fill (2)
这个构造函数用于创建一个包含 n 个元素的 std::list 容器并将这些元素初始化为 val。你可以通过传递不同的 val 值来创建一个包含相同值的容器。同样也可以传递一个可选的分配器参数。
std::listint myList(5, 42); // 创建一个包含 5 个元素每个元素都是 42 的 std::list 容器3.range (3)
这个构造函数使用迭代器范围 [first, last) 中的元素创建一个 std::list 容器。这使你可以通过一个迭代器范围来初始化容器。同样它也接受一个可选的分配器参数。
std::vectorint vec {1, 2, 3, 4, 5};
std::listint myList(vec.begin(), vec.end()); // 从迭代器范围内的元素创建 std::list 容器4. copy (4)
这个构造函数用于创建一个与已存在的 std::list 容器 x 相同的副本。它会将 x中的所有元素拷贝到新的容器中。这是一个拷贝构造函数。
std::listint originalList {1, 2, 3, 4, 5};
std::listint copiedList(originalList); // 创建一个原容器的副本这些构造函数提供了不同的初始化方式以便根据具体需求来创建 std::list 容器。根据你的数据源和其他条件选择适合的构造函数来创建容器对象。
list迭代器Iterators
1. begin()
iterator begin() noexcept; 这个版本的 begin() 返回一个迭代器可以用于修改容器内的元素。noexcept 表示这个函数不会抛出异常。
std::listint myList {1, 2, 3, 4, 5};
std::listint::iterator it myList.begin(); // 获取可修改元素的迭代器
*it 10; // 修改第一个元素的值为 10const_iterator begin() const noexcept; 这个版本的 begin() 返回一个只读的迭代器用于在不修改容器的情况下访问元素。const 表示这个函数不会修改容器。
const std::listint myList {1, 2, 3, 4, 5};
std::listint::const_iterator cit myList.begin(); // 获取只读元素的迭代器
int firstElement *cit; // 读取第一个元素的值2. end()
iterator end() noexcept; 这个版本的 end() 返回一个迭代器可以用于修改容器内的元素。noexcept 表示这个函数不会抛出异常。这个迭代器指向的位置实际上是容器的末尾位置之后一个虚拟的位置所以它并不指向容器内的任何元素。
std::listint myList {1, 2, 3, 4, 5};
std::listint::iterator it myList.end(); // 获取可修改元素的迭代器
--it; // 将迭代器前移一个位置指向最后一个元素
*it 20; // 修改最后一个元素的值为 20const_iterator end() const noexcept; 这个版本的 end() 返回一个只读的迭代器用于在不修改容器的情况下访问元素。const 表示这个函数不会修改容器。同样这个迭代器也指向虚拟的位置容器内的最后一个元素之后。
const std::listint myList {1, 2, 3, 4, 5};
std::listint::const_iterator cit myList.end(); // 获取只读元素的迭代器
--cit; // 将迭代器前移一个位置指向最后一个元素
int lastElement *cit; // 读取最后一个元素的值3. rbegin()
reverse_iterator rbegin() noexcept; 这个版本的 rbegin() 返回一个反向迭代器可以用于修改容器内的元素。noexcept 表示这个函数不会抛出异常。这个反向迭代器指向容器内的最后一个元素可以通过递减操作符 -- 往前遍历容器。
std::listint myList {1, 2, 3, 4, 5};
std::listint::reverse_iterator rit myList.rbegin(); // 获取可修改元素的反向迭代器
*rit 10; // 修改最后一个元素的值为 10
rit; // 将反向迭代器往前移动一个位置指向倒数第二个元素const_reverse_iterator rbegin() const noexcept; 这个版本的 rbegin() 返回一个只读的反向迭代器用于在不修改容器的情况下访问元素。const 表示这个函数不会修改容器。这个反向迭代器同样指向最后一个元素可以通过递减操作符 -- 往前遍历容器。
const std::listint myList {1, 2, 3, 4, 5};
std::listint::const_reverse_iterator crit myList.rbegin(); // 获取只读元素的反向迭代器
int lastElement *crit; // 读取最后一个元素的值
crit; // 将反向迭代器往前移动一个位置指向倒数第二个元素4. rend()
reverse_iterator rend() nothrow; 这个版本的 rend() 返回一个反向迭代器可以用于修改容器内的元素。nothrow 表示这个函数不会抛出异常。这个反向迭代器指向容器内的位置位于第一个元素之前可以通过递减操作符 -- 往前遍历容器。
std::listint myList {1, 2, 3, 4, 5};
std::listint::reverse_iterator rit myList.rend(); // 获取可修改元素的反向迭代器
--rit; // 将反向迭代器往前移动一个位置指向最后一个元素
*rit 10; // 修改最后一个元素的值为 10const_reverse_iterator rend() const nothrow; 这个版本的 rend() 返回一个只读的反向迭代器用于在不修改容器的情况下访问元素。const 表示这个函数不会修改容器。这个反向迭代器同样指向容器的位置位于第一个元素之前可以通过递减操作符 – 往前遍历容器。
const std::listint myList {1, 2, 3, 4, 5};
std::listint::const_reverse_iterator crit myList.rend(); // 获取只读元素的反向迭代器
--crit; // 将反向迭代器往前移动一个位置指向最后一个元素
int lastElement *crit; // 读取最后一个元素的值5. cbegin()、cend()、crbegin()、crend()
const_iterator cbegin() const noexcept; 这个成员函数返回一个指向容器元素的常量迭代器指向容器的起始位置。通过常量迭代器你可以遍历容器的元素但不能修改它们。
const_iterator cend() const noexcept; 这个成员函数返回一个指向容器元素的常量迭代器指向容器的结束位置。这个迭代器表示一个超过容器尾部的位置通常用于迭代器循环的终止条件。
std::listint myList {1, 2, 3, 4, 5};
std::listint::const_iterator cit myList.cbegin(); // 获取常量迭代器
for (; cit ! myList.cend(); cit) {std::cout *cit ; // 输出容器中的元素不修改它们
}const_reverse_iterator crbegin() const noexcept; 这个成员函数返回一个指向容器元素的常量反向迭代器指向容器的反向起始位置。通过常量反向迭代器你可以反向遍历容器的元素但不能修改它们。
const_reverse_iterator crend() const noexcept; 这个成员函数返回一个指向容器元素的常量反向迭代器指向容器的反向结束位置。这个迭代器表示一个超过容器首部的位置通常用于反向迭代器循环的终止条件。
std::listint myList {1, 2, 3, 4, 5};
std::listint::const_reverse_iterator crit myList.crbegin(); // 获取常量反向迭代器
for (; crit ! myList.crend(); crit) {std::cout *crit ; // 反向输出容器中的元素不修改它们
}list容量函数(Capacity)和元素访问函数(Element access)
1. empty()
empty() 是 std::list 容器的一个成员函数用于判断容器是否为空。它返回一个布尔值表示容器是否不包含任何元素。函数声明如下
bool empty() const noexcept;
返回值如果容器为空则返回 true否则返回 false。
使用示例
#include iostream
#include listint main() {std::listint myList;if (myList.empty()) {std::cout The list is empty. std::endl;} else {std::cout The list is not empty. std::endl;}myList.push_back(42);if (myList.empty()) {std::cout The list is empty. std::endl;} else {std::cout The list is not empty. std::endl;}return 0;
}在上面的示例中首先创建一个空的 std::list 容器 myList然后使用 empty() 函数检查容器是否为空并输出相应的信息。然后通过 push_back 向容器中添加一个元素并再次使用 empty() 函数检查容器是否为空输出相应的信息。
2. size()
size() 是 std::list 容器的一个成员函数用于返回容器中元素的数量。它返回一个无符号整数类型表示容器中的元素数量。函数声明如下
size_type size() const noexcept;
返回值返回容器中元素的数量即大小。
使用示例
#include iostream
#include listint main() {std::listint myList;myList.push_back(1);myList.push_back(2);myList.push_back(3);std::cout Size of the list: myList.size() std::endl;return 0;
}在上面的示例中我们首先创建一个 std::list 容器 myList然后使用 push_back 函数向容器中添加三个元素。然后使用 size() 函数获取容器的大小并输出到标准输出。
3. max_size()
max_size() 是 std::list 容器的一个成员函数用于返回容器可能容纳的最大元素数量通常受到系统内存限制的影响。它返回一个无符号整数类型表示容器的最大大小。函数签名如下
size_type max_size() const noexcept;
返回值返回容器可能容纳的最大元素数量。
使用示例
#include iostream
#include listint main() {std::listint 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 listint main() {std::listint 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 listint main() {std::listint 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_listvalue_type il); 这个版本接受一个初始化列表作为参数。它会将容器的内容替换为初始化列表中的元素。
使用示例
#include iostream
#include listint main() {std::listint 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::listint 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 liststruct 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::listPerson 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 listint main() {std::listint myList;int value 20;myList.push_front(value); // Copy insertstd::cout List contents: std::endl;for (const auto num : myList) {std::cout num ;}std::cout std::endl;myList.push_front(25); // Move insertstd::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::listint 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::liststd::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::listint 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::listint 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::listint 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::listint 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::listint myList {10, 20, 30, 40};
auto it myList.begin();
it; // 移动到第二个元素的位置myList.erase(it); // 删除第二个元素iterator erase (iterator first, iterator last); 删除指定范围内的元素并返回指向被删除范围之后的元素的迭代器。
参数说明
first 和 last要删除的元素范围的迭代器删除的范围包括 first但不包括 last。 返回值指向被删除范围之后的元素的迭代器。
示例用法
std::listint myList {10, 20, 30, 40};
auto it1 myList.begin();
auto it2 myList.begin();
std::advance(it2, 2); // 移动到第三个元素的位置myList.erase(it1, it2); // 删除第一个和第二个元素这些函数允许你根据需要从列表中删除一个或多个元素并返回正确的迭代器以便进行后续操作。
11. swap
void swap(list x); 是 std::list 容器的成员函数用于交换当前列表与另一个列表 x 的内容。
参数说明
x要与当前列表进行内容交换的另一个列表。
示例用法
#include iostream
#include listint main() {std::listint myList1 {1, 2, 3};std::listint myList2 {4, 5, 6};myList1.swap(myList2); // 交换两个列表的内容std::cout myList1: ;for (int num : myList1) {std::cout num ;}std::cout std::endl;std::cout myList2: ;for (int num : myList2) {std::cout num ;}std::cout std::endl;return 0;
}在上述示例中myList1 和 myList2 的内容被交换导致输出中显示的内容分别为 4 5 6 和 1 2 3。这个函数对于在不同列表之间交换内容非常有用。
12. resize
void resize(size_type n, value_type val value_type()); 是 std::list 容器的成员函数用于调整列表的大小。
参数说明
n指定调整后的大小。 val在列表扩展时用于填充新元素的值。默认值为 value_type()即类型的默认构造函数创建的值。 该函数通过在列表的末尾添加或删除元素使列表的大小调整为指定的大小 n。如果新的大小大于当前大小新元素将用指定的值 val 填充。如果新的大小小于当前大小多余的元素将被删除。
示例用法
#include iostream
#include listint main() {std::listint myList {1, 2, 3, 4, 5};myList.resize(3); // 调整列表大小为3std::cout myList after resize to 3: ;for (int num : myList) {std::cout num ;}std::cout std::endl;myList.resize(5, 0); // 调整列表大小为5并用0填充新元素std::cout myList after resize to 5 with filling 0: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在上述示例中首先调用 resize(3) 后列表中只有前3个元素保留然后调用 resize(5, 0) 后列表中总共有5个元素其中新添加的2个元素被填充为0。
13. clear
void clear(); 是 std::list 容器的成员函数用于清空列表中的所有元素使列表变为空列表。
该函数会删除列表中的所有元素使列表变为空但并不会释放列表所占用的内存空间所以列表的容量不会变化。这可以有效地回收元素所占用的资源但保留容量可以减少频繁的内存分配和释放操作以提高性能。
示例用法
#include iostream
#include listint main() {std::listint myList {1, 2, 3, 4, 5};std::cout myList before clear: ;for (int num : myList) {std::cout num ;}std::cout std::endl;myList.clear(); // 清空列表std::cout myList after clear: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在上述示例中首先输出了清空前的列表元素然后调用 clear() 后列表中的所有元素被删除输出了清空后的列表元素此时列表为空。
list操作函数(Operations)
1. splice
void splice (iterator position, list x); 该成员函数用于将另一个列表 x 中的所有元素移动到当前列表中插入到指定位置 position 前。x 列表在移动后会变为空列表。
示例用法
#include iostream
#include listint main() {std::listint myList1 {1, 2, 3};std::listint myList2 {4, 5, 6};auto it myList1.begin();std::advance(it, 2);myList1.splice(it, myList2); // 将 myList2 的元素插入到 myList1 中std::cout myList1 after splice: ;for (int num : myList1) {std::cout num ;}std::cout std::endl;std::cout myList2 after splice: ;for (int num : myList2) {std::cout num ;}std::cout std::endl;return 0;
}void splice (iterator position, list x, iterator i); 该成员函数用于将另一个列表 x 中的元素移动到当前列表中插入到指定位置 position 前但只移动另一个列表 x 中的迭代器 i 指向的元素。
示例用法
#include iostream
#include listint main() {std::listint myList1 {1, 2, 3};std::listint myList2 {4, 5, 6};auto it1 myList1.begin();std::advance(it1, 1);auto it2 myList2.begin();myList1.splice(it1, myList2, it2); // 将 myList2 中的第一个元素插入到 myList1 中std::cout myList1 after splice: ;for (int num : myList1) {std::cout num ;}std::cout std::endl;std::cout myList2 after splice: ;for (int num : myList2) {std::cout num ;}std::cout std::endl;return 0;
}void splice (iterator position, list x, iterator first, iterator last); 该成员函数用于将另一个列表 x 中的一段元素范围 [first, last) 移动到当前列表中插入到指定位置 position 前。
示例用法
#include iostream
#include listint main() {std::listint myList1 {1, 2, 3};std::listint myList2 {4, 5, 6};auto it1 myList1.begin();std::advance(it1, 1);auto it2_first myList2.begin();auto it2_last myList2.begin();std::advance(it2_last, 2);myList1.splice(it1, myList2, it2_first, it2_last); // 将 myList2 中的前两个元素插入到 myList1 中std::cout myList1 after splice: ;for (int num : myList1) {std::cout num ;}std::cout std::endl;std::cout myList2 after splice: ;for (int num : myList2) {std::cout num ;}std::cout std::endl;return 0;
}这些 splice 函数允许你在列表中移动元素从一个列表中移动到另一个列表中或在同一列表内重新排列元素的位置而不需要进行元素的复制和删除。
2. remove
void remove (const value_type val); 该成员函数用于从列表中移除所有等于给定值 val 的元素。
示例用法
#include iostream
#include listint main() {std::listint myList {1, 2, 3, 2, 4, 2, 5};myList.remove(2); // 移除列表中所有值为 2 的元素std::cout myList after remove: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在示例中myList 列表中的值为 2 的元素被移除最终输出为 1 3 4 5。
3. remove_if
template class Predicate void remove_if (Predicate pred); 这个成员函数用于根据给定的谓词函数 pred 移除满足特定条件的元素。
谓词函数 pred 接受一个参数并返回一个布尔值用于判断是否需要移除该元素。如果谓词返回 true则该元素将被移除。
示例用法
#include iostream
#include listbool isEven(int num) {return num % 2 0;
}int main() {std::listint myList {1, 2, 3, 4, 5, 6, 7, 8, 9};myList.remove_if(isEven); // 移除列表中所有偶数std::cout myList after remove_if: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在示例中myList 列表中的偶数元素被移除最终输出为 1 3 5 7 9。函数 isEven 是一个谓词函数用于判断是否为偶数。
4. unique
void unique(); 这个成员函数用于移除列表中相邻的重复元素。它只保留第一个出现的重复元素移除后续的重复元素。
示例用法
#include iostream
#include listint main() {std::listint myList {1, 2, 2, 3, 4, 4, 4, 5};myList.unique(); // 移除相邻的重复元素std::cout myList after unique: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在示例中myList 列表中的相邻重复元素被移除最终输出为 1 2 3 4 5。
template class BinaryPredicate void unique (BinaryPredicate binary_pred); 这个成员函数在移除相邻重复元素时使用自定义的二元谓词函数 binary_pred 来判断是否为重复元素。该谓词函数接受两个参数并返回一个布尔值用于判断两个元素是否相等。
示例用法
#include iostream
#include listbool isEqual(int a, int b) {return a b;
}int main() {std::listint myList {1, 2, 2, 3, 4, 4, 4, 5};myList.unique(isEqual); // 使用 isEqual 判断是否为重复元素std::cout myList after unique with custom predicate: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在示例中通过自定义的谓词函数 isEqual 判断相邻的元素是否相等移除相邻的重复元素最终输出为 1 2 3 4 5。
5. merge
void merge(list x); 这个成员函数用于将另一个列表 x 合并到当前列表中合并后的列表会按照升序排列。
示例用法
#include iostream
#include listint main() {std::listint myList1 {1, 3, 5};std::listint myList2 {2, 4, 6};myList1.merge(myList2); // 将 myList2 合并到 myList1 中std::cout myList1 after merge: ;for (int num : myList1) {std::cout num ;}std::cout std::endl;return 0;
}在示例中myList2 列表被合并到了 myList1 中合并后的列表按照升序排列最终输出为 1 2 3 4 5 6。
template class Compare void merge(list x, Compare comp); 这个成员函数与上面的 merge 函数类似但是它允许提供一个自定义的比较函数 comp 来决定合并后的顺序。
示例用法
#include iostream
#include listbool descendingOrder(int a, int b) {return a b;
}int main() {std::listint myList1 {5, 3, 1};std::listint myList2 {6, 4, 2};myList1.merge(myList2, descendingOrder); // 使用自定义比较函数合并std::cout myList1 after merge with custom comparison: ;for (int num : myList1) {std::cout num ;}std::cout std::endl;return 0;
}在示例中通过自定义的比较函数 descendingOrder将 myList2 列表合并到了 myList1 中合并后的列表按照降序排列最终输出为 6 5 4 3 2 1。
6. sort
void sort(); 这个成员函数用于对列表进行升序排序默认使用 运算符进行比较。
示例用法
#include iostream
#include listint main() {std::listint myList {5, 3, 1, 4, 2};myList.sort(); // 对列表进行升序排序std::cout myList after sorting: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在示例中列表中的元素经过排序后变为 1 2 3 4 5。
template class Compare void sort(Compare comp); 这个成员函数与上面的 sort 函数类似但是它允许提供一个自定义的比较函数 comp 来决定排序的顺序。
示例用法
#include iostream
#include listbool descendingOrder(int a, int b) {return a b;
}int main() {std::listint myList {5, 3, 1, 4, 2};myList.sort(descendingOrder); // 使用自定义比较函数进行降序排序std::cout myList after custom sorting: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在示例中通过自定义的比较函数 descendingOrder列表中的元素经过排序后变为 5 4 3 2 1。
7. reverse
void reverse(); 函数用于将列表中的元素逆序排列。
示例用法
#include iostream
#include listint main() {std::listint myList {1, 2, 3, 4, 5};myList.reverse(); // 将列表中的元素逆序排列std::cout myList after reversing: ;for (int num : myList) {std::cout num ;}std::cout std::endl;return 0;
}在示例中列表中的元素经过逆序排列后变为 5 4 3 2 1。
list的迭代器失效
迭代器失效即迭代器所指向的节点的无效即该节点被删除了。因为list的底层结构为带头结点的双向循环链表因此在list中进行插入时是不会导致list的迭代器失效的只有在删除时才会失效并且失效的只是指向被删除节点的迭代器其他迭代器不会受到影响。
当使用 std::list 进行删除操作时可能会导致迭代器失效。下面是一个示例
#include iostream
#include listint main() {std::listint myList {1, 2, 3, 4, 5};auto it myList.begin();it; // Move the iterator to the second elementmyList.erase(it); // Erase the second elementfor (auto num : myList) {std::cout num ;}return 0;
}在上面的示例中当我们在第二个元素位置处使用 erase 函数删除元素后迭代器 it 就会失效因为它指向的元素已经被删除。如果我们尝试使用失效的迭代器可能会导致未定义的行为。
要修正这个问题可以使用 erase 函数的返回值它会返回一个指向下一个有效元素的迭代器
#include iostream
#include listint main() {std::listint myList {1, 2, 3, 4, 5};auto it myList.begin();it; // Move the iterator to the second elementit myList.erase(it); // Erase the second element and update the iteratorfor (auto num : myList) {std::cout num ;}return 0;
}在这个修正后的示例中我们使用 erase 函数的返回值更新了迭代器 it以确保它指向的是有效的元素。这样就避免了使用失效迭代器引发的问题。
结语
有兴趣的小伙伴可以关注作者如果觉得内容不错请给个一键三连吧蟹蟹你哟 制作不易如有不正之处敬请指出 感谢大家的来访UU们的观看是我坚持下去的动力 在时间的催化剂下让我们彼此都成为更优秀的人吧
