【十四】【C++】list 的常见用法
list 的初始化和遍历
/*list的初始化和遍历*/
#if 1
#include
#include
#include
#include
using namespace std;
void TestList1()
{
list L1;
list L2(10, 5);
vector v{1,2,3,4,5};
list L3(v.begin(), v.end());
list L4(L3);
// C++11
list L5{ 1, 2, 3, 4, 5 };
/
// 链表遍历
for (auto e : L2)
cout << e << " ";
cout << endl;
// list::iterator it = L3.begin();
auto it = L3.begin();
while (it != L3.end())
{
cout << *it << " ";
++it;
}
cout << endl;
auto rit = L4.rbegin();
while (rit != L4.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
// 注意：list不能使用原生态指针，即Node*来遍历链表
// 因为list没有提供获取头指针的方法
}
int main(){
TestList1();
}
#endif
std::list 是一个双向链表，提供了双向序列的特性，包括有效地进行插入、删除操作等，但不支持随机访问。
初始化 std::list
空初始化： list 创建了一个空的 int 类型的 list。
填充初始化： list 创建了一个包含 10 个元素，每个元素都初始化为 5 的 list。
范围初始化： list 使用 vector 的迭代器范围来初始化 L3，即将 v 中的元素复制到 L3 中。
拷贝初始化： list 使用另一个 list L3 来初始化 L4，复制 L3 的所有元素。
列表初始化 （C++11）: list 使用初始化列表直接初始化 L5。
链表遍历
范围 for 循环： 使用范围 for 循环遍历 L2，打印出其所有元素。这是 C++11 引入的一种简洁的遍历容器的方式。
使用迭代器： 通过迭代器 it 遍历 L3，同样打印出所有元素。std::list 提供的迭代器是双向迭代器。
使用反向迭代器： 通过反向迭代器 rit 遍历 L4，但这次是逆序打印出所有元素。反向迭代器从容器的末尾开始遍历至开始。
注意
代码中提到，“list不能使用原生态指针，即 Node*来遍历链表”，这是因为 std::list 的实现细节被抽象化了，用户无法像操作普通链表那样通过节点指针进行遍历或访问。std::list 提供了迭代器来抽象这些细节，使得操作更安全、更容易。
list 的 resize 操作探究
/*list的resize操作探究*/
#if 1
#include
#include
#include
#include
using namespace std;
void TestList2()
{
list L{ 1, 2, 3, 4, 5 };
cout << L.size() << endl;
L.resize(10, 6);
for (auto e : L)
cout << e << " ";
cout << endl;
L.resize(20);
for (auto e : L)
cout << e << " ";
cout << endl;
L.resize(7);
for (auto e : L)
cout << e << " ";
cout << endl;
}
int main(){
TestList2();
}
#endif
resize 方法用于调整链表的大小，即元素的数量。以下是对 TestList2 函数中各个操作的详细解释：
初始化 std::list
list
使用初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的 list。
调整大小并填充新元素
L.resize(10, 6);
调整 L 的大小至 10 个元素。由于新大小大于当前大小，resize 方法会添加额外的元素。在这个例子中，新增的元素被初始化为 6。因此，调整后的 list 包含元素 {1, 2, 3, 4, 5, 6, 6, 6, 6, 6}。
再次调整大小，使用默认值填充
L.resize(20);
这次 L 的大小被调整至 20 个元素。因为没有指定新元素的初始化值，新增的元素会被默认初始化。对于整数类型，这意味着它们被初始化为 0。现在，list 包含 {1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}。
减少 list 的大小
L.resize(7);
L 的大小被减少至 7 个元素。resize 方法会移除超出新大小的元素。因此，list 现在包含 {1, 2, 3, 4, 5, 6, 6}。
在每次调整大小之后，代码通过一个范围 for 循环遍历 L 并打印其所有元素，这样可以直观地看到 resize 操作的结果。
list 的插入删除操作探究
/*list的插入删除操作探究*/
#if 1
#include
#include
#include
#include
using namespace std;
void TestList3()
{
list L{ 1, 2, 3, 4, 5 };
L.push_back(6);
L.push_back(7);
L.push_back(8);
L.push_back(9);
cout << L.size() << endl;
cout << L.front() << endl;
cout << L.back() << endl;
L.pop_back();
L.pop_back();
for (auto e : L)
cout << e << " ";
cout << endl;
L.push_front(0);
for (auto e : L)
cout << e << " ";
cout << endl;
L.pop_front();
for (auto e : L)
cout << e << " ";
cout << endl;
L.insert(L.begin(), 0);
auto pos = find(L.begin(), L.end(), 5);
if (pos != L.end())
L.insert(pos, 5, 8);
int array[] = { 10, 20, 30, 40, 50 };
L.insert(L.end(), array, array + sizeof(array) / sizeof(array[0]));
}
int main(){
TestList3();
}
#endif
std::list 是一个双向链表，支持在任何位置高效插入和删除元素。
初始化 std::list
list
使用初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的链表 L。
添加元素到链表尾部
通过 push_back 方法，在链表的尾部依次添加了元素 6、7、8 和 9。
L.push_back(6);
L.push_back(7);
L.push_back(8);
L.push_back(9);
这些操作将 L 扩展为 {1, 2, 3, 4, 5, 6, 7, 8, 9}。
移除链表尾部的元素
通过 pop_back 方法移除了链表尾部的两个元素（8 和 9）。
L.pop_back();
L.pop_back();
L 现在包含 {1, 2, 3, 4, 5, 6, 7}。
在链表头部添加元素
通过 push_front 方法在链表的头部添加了元素 0。
L.push_front(0);
L 现在包含 {0, 1, 2, 3, 4, 5, 6, 7}。
移除链表头部的元素
通过 pop_front 方法移除了链表头部的元素 0。
L.pop_front();
L 恢复为 {1, 2, 3, 4, 5, 6, 7}。
在链表特定位置插入元素
首先，在链表的开始位置插入元素 0。
L.insert(L.begin(), 0);
然后，找到元素 5 的位置，并在该位置前插入五个 8。
auto pos = find(L.begin(), L.end(), 5);
if (pos != L.end())
L.insert(pos, 5, 8);
这使得 L 变为 {0, 1, 2, 3, 4, 8, 8, 8, 8, 8, 5, 6, 7}。
从数组中插入多个元素
通过 insert 方法，将一个整型数组 {10, 20, 30, 40, 50} 的所有元素插入到链表的末尾。
int array[] = { 10, 20, 30, 40, 50 };
L.insert(L.end(), array, array + sizeof(array) / sizeof(array[0]));
这将数组中的元素添加到了 L 的末尾，使得 L 最终包含 {0, 1, 2, 3, 4, 8, 8, 8, 8, 8, 5, 6, 7, 10, 20, 30, 40, 50}。
list 的 erase、assign 操作探究
/*list的erase、assign操作探究*/
#if 1
#include
#include
#include
#include
using namespace std;
void TestList4()
{
list L{ 1, 2, 3, 4, 5 };
L.push_back(6);
L.push_back(7);
L.push_back(8);
L.push_back(9);
L.erase(L.begin());
L.erase(find(L.begin(), L.end(), 8));
L.erase(L.begin(), L.end()); // clear();
L.assign(10, 5);
int array[] = { 10, 20, 30, 40, 50 };
L.assign(array, array + sizeof(array) / sizeof(array[0]));
}
int main(){
TestList4();
}
#endif
初始链表的创建和元素添加
list
L.push_back(6);
L.push_back(7);
L.push_back(8);
L.push_back(9);
首先，通过初始化列表创建一个包含 {1, 2, 3, 4, 5} 的 list，然后依次添加元素 6、7、8 和 9 到链表的末尾，使得链表变为 {1, 2, 3, 4, 5, 6, 7, 8, 9}。
删除链表中的元素
L.erase(L.begin());
删除链表的第一个元素（1）。此时链表变为 {2, 3, 4, 5, 6, 7, 8, 9}。
L.erase(find(L.begin(), L.end(), 8));
使用 find 函数查找值为 8 的元素，并将其删除。此时链表变为 {2, 3, 4, 5, 6, 7, 9}。
L.erase(L.begin(), L.end()); // clear();
删除链表中从开始到结束的所有元素，相当于清空整个链表。这行代码实际上清空了链表，使其不包含任何元素。
重新分配链表内容
L.assign(10, 5);
assign 方法用于将链表的内容替换为指定数量（这里是 10）的重复元素（这里是 5）。执行这个操作后，链表包含了 10 个值为 5 的元素。
使用数组重新分配链表内容
int array[] = { 10, 20, 30, 40, 50 };
L.assign(array, array + sizeof(array) / sizeof(array[0]));
再次使用 assign 方法，但这次是用数组的元素来重新分配链表的内容。通过计算数组的大小，将整个 array 的内容赋值给链表 L。执行这个操作后，链表的内容变为 {10, 20, 30, 40, 50}。
list 的 remove、sort、unique、reverse 操作探究
/*list的remove、sort、unique、reverse操作探究*/
#if 1
#include
#include
#include
#include
using namespace std;
void TestList5() {
list L{ 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 1, 1};
L.remove(1);
L.sort();
L.unique();
L.reverse();
}
int main() {
TestList5();
}
#endif
初始链表的创建
list
首先，通过初始化列表创建了一个包含重复元素的 list。
删除特定元素
L.remove(1);
remove 方法从链表中删除所有值为 1 的元素。执行这个操作后，链表中所有的 1 被移除，链表变为 {2, 3, 4, 5, 2, 3, 4, 5}。
对链表进行排序
L.sort();
sort 方法对链表中的元素进行排序。std::list 提供了自己的 sort 成员函数，因为标准算法库中的 std::sort 需要随机访问迭代器，而 list 只提供双向迭代器。排序后，链表变为 {2, 2, 3, 3, 4, 4, 5, 5}。
移除连续重复的元素
L.unique();
unique 方法移除链表中连续重复的元素，只保留了每组重复元素中的第一个元素。在排序后的链表中应用 unique，会移除所有的连续重复项，链表变为 {2, 3, 4, 5}。
反转链表
L.reverse();
reverse 方法将链表中的元素反向排列。执行这个操作后，链表中的元素顺序被反转，即 {5, 4, 3, 2}。
list 的 remove_if 操作探究
/*list的remove_if操作探究*/
#if 1
#include
#include
#include
#include
using namespace std;
bool IsEven(int data) {
// 5的二进制：0000 0101
// 0000 0001
// return 0 == (data & 0x01);
return 0 == data % 2;
}
void TestList6() {
list L{ 1, 2, 3, 4, 5 };
L.push_back(6);
L.push_back(7);
L.push_back(8);
L.push_back(9);
L.remove_if(IsEven);
}
int main() {
TestList6();
}
#endif
remove_if 方法允许用户指定一个谓词（一个返回布尔值的函数或函数对象），根据这个谓词来决定哪些元素应该被移除。
定义判定函数
bool IsEven(int data) {
return 0 == data % 2;
}
这个函数 IsEven 检查给定的整数是否为偶数。如果是偶数，返回 true；否则返回 false。
初始化 std::list 并添加元素
list
L.push_back(6);
L.push_back(7);
L.push_back(8);
L.push_back(9);
首先，通过初始化列表创建了一个包含元素 {1, 2, 3, 4, 5} 的 list，然后依次添加了元素 6、7、8 和 9 到链表的末尾。
使用 remove_if 根据条件移除元素
L.remove_if(IsEven);
remove_if 方法接受一个谓词函数 IsEven 作为参数，并移除 L 中所有使得 IsEven 返回 true 的元素。在这个例子中，它会移除链表中所有的偶数。
执行 remove_if 之后，原始链表 {1, 2, 3, 4, 5, 6, 7, 8, 9} 中的偶数元素被移除，留下了 {1, 3, 5, 7, 9}。
list 的迭代器失效探究
/*list的迭代器失效探究*/
#if 1
#include
#include
#include
#include
using namespace std;
void TestList7() {
list L{ 1, 2, 3, 4, 5 };
L.push_back(6);
L.push_back(7);
L.push_back(8);
L.push_back(9);
//1
auto it = L.begin();
L.pop_front();
while (it != L.end())
{
cout << *it << " ";
++it;
}
//2
L.resize(0);
while (it != L.end())
{
cout << *it << " ";
++it;
}
//3
L.assign(10, 5);
list L1{ 10, 20, 30, 40, 50 };
L = L1;
while (it != L.end())
{
cout << *it << " ";
++it;
}
//4
while (it != L.end()) {
// L.erase(it);
// ++it;
it = L.erase(it);
}
}
int main() {
TestList7();
}
#endif
初始化列表和添加元素
list
L.push_back(6);
L.push_back(7);
L.push_back(8);
L.push_back(9);
这段代码初始化了一个包含 {1, 2, 3, 4, 5, 6, 7, 8, 9} 的 list。
删除链表的第一个元素
auto it = L.begin();
L.pop_front();
it 初始化为指向链表的第一个元素。随后，pop_front() 删除了链表的第一个元素。由于 it 此时指向的元素被删除，it 的状态变得未定义，导致迭代器失效。正确的做法是在删除操作之后重新获取 begin() 的迭代器。
清空链表
L.resize(0);
这段代码将链表的大小调整为 0，相当于清空了链表。此时，除了 end() 迭代器之外，任何其他迭代器都变得无效，包括之前的 it。
stl_list_h 中"operator ="底层代码
/*operator = 重载*/
template
list& list::operator=(const list& x) {
if (this != &x) {
iterator first1 = begin();
iterator last1 = end();
const_iterator first2 = x.begin();
const_iterator last2 = x.end();
while (first1 != last1 && first2 != last2) *first1++ = *first2++;
if (first2 == last2)
erase(first1, last1);
else
insert(last1, first2, last2);
}
return *this;
} template
这一行声明了一个模板函数，这个函数是list类的成员函数，用于重载赋值运算符=。T是列表中存储元素的类型，而Alloc是分配器类型，用于控制元素的内存分配。该函数接收一个常量引用x作为参数，这个参数是另一个list对象，表示要从中复制数据。函数返回对当前对象的引用，允许链式赋值。
if (this != &x) {
这一行检查自赋值的情况。如果被赋值的对象（*this）和赋值来源对象（x）是同一个对象，则不执行任何操作。这是为了防止自我复制时可能发生的资源泄露或不必要的操作。
iterator first1 = begin(); iterator last1 = end(); const_iterator first2 = x.begin(); const_iterator last2 = x.end();
这四行代码初始化四个迭代器。first1和last1分别是当前list对象的起始和结束位置的迭代器。first2和last2是参数x（即要复制的list对象）的起始和结束位置的常量迭代器。
while (first1 != last1 && first2 != last2) *first1++ = *first2++;
这行代码在两个列表都没有遍历完之前，逐个元素地从x复制元素到当前对象。*first1++ = *first2++这个表达式复制元素值，并将两个迭代器分别向前移动到下一个元素。
if (first2 == last2)erase(first1, last1);elseinsert(last1, first2, last2);
在完成上述循环后，会有两种情况：
如果x的元素已经复制完，但当前对象中还有剩余元素，这些剩余元素需要被删除。这通过调用erase(first1, last1)实现，它删除从first1到last1（不包括last1）范围内的所有元素。
如果当前对象的元素已经被完全覆盖，但x中还有未复制的元素，这些元素需要被插入到当前对象的末尾。这通过调用insert(last1, first2, last2)实现，它从first2到last2的范围内插入元素到last1位置之前。
return *this;
最后，函数返回当前对象的引用，使得可以进行链式赋值操作（例如，a = b = c）。
重新分配链表内容
L.assign(10, 5);
list
L = L1;
assign底层实现和operator=大致是相同的。根据迭代器指向的位置元素是否被销毁来判断迭代器是否失效。示例代码迭代器没有发生失效。
删除操作
while (it != L.end()) {
it = L.erase(it);
}
这种模式是正确的方式来删除链表中的元素，因为 erase 返回指向被删除元素下一个元素的迭代器。
结尾
最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。
同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。
谢谢您的支持，期待与您在下一篇文章中再次相遇！