在下马农

在下马农

关注
发信
关注(28)粉丝(399)

list用法深度解析，一篇文章弄懂list容器各种操作

list用法深度解析，一篇文章弄懂list容器各种操作-LMLPHP

以下是正文

1、list介绍

1.1 list容器的存储结构

list用法深度解析，一篇文章弄懂list容器各种操作-LMLPHP

1.2 list容器优点：

  • 高效的插入和删除：由于std::list是基于双向链表实现的，插入和删除操作在任意位置都具有常数时间复杂度O(1)，不需要移动其他元素。这使得std::list在需要频繁插入和删除元素的场景下非常高效。
  • 稳定的迭代器：在std::list中进行插入和删除操作不会使得迭代器失效。这意味着在插入或删除元素后，仍然可以继续使用之前获取的迭代器进行遍历和操作。
  • 动态内存管理：std::list可以动态调整大小，根据需要分配和释放内存。这使得std::list能够有效地处理大量元素的情况，而不会浪费过多的内存空间。

1.3 list容器缺点：

  • 低效的随机访问：由于std::list的存储结构是双向链表，访问元素时需要从头或尾开始遍历链表，因此在列表中进行随机访问的效率较低。获取特定位置的元素需要遍历链表，时间复杂度为O(n)，其中n是元素的总数量。
  • 占用额外内存：相较于其他容器，std::list在存储上需要额外的指针来维护链表结构，因此在存储大量元素时，它可能占用更多的内存空间。
  • 迭代器不支持指针算术：std::list的迭代器不支持指针算术运算，无法像指针那样直接进行加减操作，这限制了一些操作的灵活性。

头文件：
list是C++ 标准模板库的一部分，因此，想要使用list，需要在程序中包含头文件 list

#include<list>

2、list定义和初始化

格式：
包含头文件list之后，我们可以使用下边的格式定义list：

std::list<T> myList;  // 创建一个名为myList的空列表，其中T是列表中元素的类型

T规定了list中可以存放哪种类型的元素。
myList为list名。

方式： 定义list的常用方式如下所示：

list<Type> v1; 				//v1是一个空list,可存储元素类型为T，执行默认初始化
list<Type> v2(v1);			//v2中包含v1中的所有元素
list<Type> v3 = v1;			//等价于v2(v1)
list<Type> v4(n,value);		//v3中有n个元素，并且值都为value
list<Type> v5(n);				//v4包含了n个重复执行了值初始化的对象
list<Type> v6{a,b,c.....};	//v5包含大括号中的所有元素
list<Type> v7 = {a,b,c...}；	//等价于v5{a,b,c....}

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> test;
    list<int> test1 = {1, 2};
    list<int> test2(test1);
    list<int> test3 = test1;
    list<int> test4(3, 2);
    list<int> test5(5);
    list<int> test6{1, 2, 3, 4, 5};
    list<int> test7 = {1, 2, 3, 4, 5, 6};

    cout << "test:";
    for (auto a : test) {
        cout << a << " ";
    }
    cout << endl << "test1: ";
    for (auto b : test1) {
        cout << b << " ";
    }
    cout << endl << "test2: ";
    for (auto b : test2) {
        cout << b << " ";
    }
    cout << endl << "test3: ";
    for (auto b : test3) {
        cout << b << " ";
    }
    cout << endl << "test4: ";
    for (auto b : test4) {
        cout << b << " ";
    }
    cout << endl << "test5: ";
    for (auto b : test5) {
        cout << b << " ";
    }
    cout << endl << "test6: ";
    for (auto b : test6) {
        cout << b << " ";
    }
    cout << endl << "test7: ";
    for (auto b : test7) {
        cout << b << " ";
    }
}

📄输出📄

上边的例子中，使用各种方式初始化创建list，可以根据需要选择使用。

3、list的迭代器

list用法深度解析，一篇文章弄懂list容器各种操作-LMLPHP

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> test = {1, 2, 3, 4};
    cout << "初始化后list为： ";
    for (auto num : test) {
        cout << num << " ";
    }
    cout << endl;

    // list.begin()为指向list头元素的迭代器
    list<int>::iterator begin_iterator = test.begin();
    cout << "begin() 指向的元素：" << *begin_iterator << endl;

    // list.end()为指向list尾元素后一个位置的迭代器，则test.end()指向位置的前一个元素是最后一个元素
    auto end_iterator = test.end();
    // end指向位置的前一个元素才是最后一个元素
    end_iterator--;
    cout << "end() 指向位置的前一个元素: " << *end_iterator << endl;

    // list.rbegin()为指向尾元素的迭代器，即反向(r)的头(begin)迭代器
    auto rbegin_iterator = test.rbegin();
    cout << "rbegin() 指向的元素：" << *rbegin_iterator << endl;

    // list.rend()为指向头元素的前一个位置的迭代器，即反向(r)尾(end)迭代器，则test.rend()指向位置的后一个元素指向头元素
    auto rend_iterator = test.rend();

    rend_iterator--;
    cout << "rend()指向位置的后一个元素：" << *rend_iterator << endl;

    // list.cbegin()为指向list头元素的const迭代器
    // 与begin()不同的是返回迭代器类型为list<int>::const_iterator，不可修改元素
    list<int>::const_iterator cbegin_iterator = test.cbegin();
    cout << "cbegin() 指向的元素：" << *cbegin_iterator << endl;

    // list.cend()为指向list尾元素下一个位置的const迭代器
    // 与end()不同的是返回迭代器类型为list<int>::const_iterator，不可修改元素
    list<int>::const_iterator cend_iterator = test.cend();
    cend_iterator--;
    cout << "cend()指向位置的前一个元素：" << *cend_iterator << endl;

    // list.crbegin()为指向尾元素的const迭代器，即反向(r)的const(c)头(begin)迭代器
    auto crbegin_iterator = test.crbegin();
    cout << "crbegin() 指向的元素： " << *crbegin_iterator << endl;

    // list.crend()为指向头元素下一个位置的const迭代器，即反向(r)的const(c)尾(end)迭代器
    auto crend_iterator = test.crend();
    crend_iterator--;
    cout << "crend()指向位置的后一个元素： " << *crend_iterator << endl;

    return 0;
}

📄输出📄

4、list容器的成员方法

除了上述返回list迭代器的成员函数之外，list还有一些其他的成员函数

（1） size()——元素个数

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist1 = {2, 3};
    list<int> mylist2 = {1, 2, 3, 4};
    cout<< "mylist1中元素个数为 = "<< mylist1.size()<< endl;
    cout<< "mylist2中元素个数为 = "<< mylist2.size()<< endl;
}

📄输出📄

（2） max_size()——最多能容纳元素个数：

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist = {2, 3};
    cout<< "mylist最多可容纳元素个数尾max_size() = "<< mylist.max_size()<<endl;
}

📄输出📄

（3） resize(n)——改变list大小为n

resize()方法有两种重载形式：

  • void resize(size_type count, const T& value = T()):
    这个重载会将列表的大小调整为count。如果count大于当前列表的大小，则在列表末尾插入足够数量的值为value的元素。如果count小于当前列表的大小，则删除超出count的元素。

  • void resize(size_type count):
    这个重载会将列表的大小调整为count。如果count大于当前列表的大小，则在列表末尾插入默认构造的元素。如果count小于当前列表的大小，则删除超出count的元素。

💻示例代码💻

#include <iostream>
#include <list>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist = {1, 2};
    // 把mylist的大小设为5
    mylist.resize(5);
    cout << "第一次resize后list中元素为：";
    for (auto a : mylist) {
        cout << a << " ";
    }
    cout << endl;
    // 把mylist的大小设为1
    mylist.resize(1);
    cout << "第二次resize后list中元素为：";
    for (auto a : mylist) {
        cout << a << " ";
    }
    cout << endl;

    // 把list大小设为4，不足部分填充5
    mylist.resize(4, 5);
    cout << "第三次resize后list中元素为：";
    for (auto a : mylist) {
        cout << a << " ";
    }
    cout << endl;
}

📄输出📄

（4） empty()——判断list是否为空

💻示例代码💻

#include<iostream>
#include<list>

using std::cout;
using std::endl;
using std::list;

int main () {
    list<int> mylist1;
    list<int> mylist2 = {1, 2};
    cout<< "mylist1是否为空？"<< mylist1.empty() << endl;
    cout<< "mylist2是否为空？"<< mylist2.empty() << endl;
}

📄输出📄

（5） front()——访问list头元素

💻示例代码💻

#include<iostream>
#include<list>

using std::cout;
using std::endl;
using std::list;

int main() {
    list<int> mylist {1, 2, 3, 4, 5, 6, 7, 8};
    cout<< "初始化后的mylist为：";
    for (auto num : mylist) {
        cout<< num<< " ";
    }
    int front = mylist.front();

    cout<< "\nmylist的头元素为："<< front;
}

📄输出📄

（6） back()——访问list尾元素

💻示例代码💻

#include<iostream>
#include<list>

using std::cout;
using std::endl;
using std::list;

int main() {
    list<int> mylist {1, 2, 3, 4, 5, 6, 7, 8};
    cout<< "初始化后的mylist为：";
    for (auto num : mylist) {
        cout<< num<< " ";
    }
    int front = mylist.front();

    cout<< "\nmylist的头元素为："<< front;
}

📄输出📄

（7） assign()——指定list元素

❤assign的作用就是用新的元素替换list中旧的元素❤

用法一：list.assign(num,value)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    mylist.assign(3, 2);
    cout << "\nassign之后mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

用法二：list.assign(iterator1,iterator2)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist1{1, 2, 3, 4};
    list<int> mylist2{5, 6, 7, 8};
    cout << "初始化后的mylist1为：";
    for (auto num : mylist1) {
        cout << num << " ";
    }
    cout << "\n初始化后的mylist2为：";
    for (auto num : mylist2) {
        cout << num << " ";
    }
    // it1指向mylist1头元素的下一个元素，即第二个元素
    list<int>::iterator it1 = ++mylist1.begin();
    // it2指向mylist1尾元素
    list<int>::iterator it2 = --mylist1.end();

    // 用[*it1,*it2)的元素替换mylist2中的元素
    mylist2.assign(it1, it2);

    cout << "\nassign后的mylist2为：";
    for (auto num : mylist2) {
        cout << num << " ";
    }
}

📄输出📄

用法三：list.assign(address1,address2)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist1{1, 2, 3, 4};
    int a[5] = {10,20,30,40,50};
    cout << "初始化后的mylist1为：";
    for (auto num : mylist1) {
        cout << num << " ";
    }
    
    // a[2]为30，a[4]为50，则用[a[2],a[4])的元素替换mylist1中元素
    mylist1.assign(&a[2], &a[4]);

    cout << "\nassign后的mylist1为：";
    for (auto num : mylist1) {
        cout << num << " ";
    }
}

📄输出📄

（8） push_back()——添加元素（list尾部)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // 在list尾部插入一个元素8
    mylist.push_back(8);
    cout << "\n尾部插入一个元素后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（9） push_front()——添加元素（list头部)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};

    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // 在list尾部插入一个元素8
    mylist.push_front(8);

    cout << "\n头部插入一个元素后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（10） pop_back()——移除list元素(尾部)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // 删除mydeue尾部一个元素
    mylist.pop_back();
    cout << "\n尾部删除一个元素后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（11） pop_front()——删除list元素(头部)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // 删除mydeue头部一个元素
    mylist.pop_front();
    cout << "\n头部删除一个元素后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（12） insert()——添加元素（任意位置）

用法一：list.insert(iterator,value)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // it指向mylist的第二个元素
    list<int>::iterator it = mylist.begin() + 1;
    // 使用insert添加一个元素
    list<int>::iterator itnew = mylist.insert(it, 10);
    cout << "\n返回的迭代器指向的元素为" << *itnew;
    cout << "\ninsert添加一个元素后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

用法二：list.insert(iterator,num,value)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // it指向mylist的第二个元素
    list<int>::iterator it = mylist.begin() + 1;

    // 使用insert添加2个元素，value为20
    mylist.insert(it, 2, 20);
    cout << "\n使用insert插入元素后：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

用法三：insert(iterator, iterator1, iterator2)

示例如下：

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // it指向mylist的第二个元素
    list<int>::iterator it = mylist.begin() + 1;
    // 定义一个辅助list
    list<int> list2{10, 20, 30};
    // it1指向list2的第一个元素
    list<int>::iterator it1 = list2.begin();
    // it2指向list2的最后一个元素后一个位置
    list<int>::iterator it2 = list2.end();
    // 使用insert在2之前添加[it1,it2)之间的元素
    mylist.insert(it, it1, it2);
    cout << "\n使用insert插入元素后：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

用法四：insert(iterator, std::initializer_list)

示例如下：

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // it指向mylist的第二个元素
    list<int>::iterator it = ++mylist.begin();

    // 使用insert在2之前添加元素
    mylist.insert(it, {100, 200, 300});
    cout << "\n使用insert插入元素后：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（13） erase()——删除元素（任意位置）

❤erase的作用就是根据传入的迭代器删除list中的元素,参数为一个迭代器，只删除迭代器指向的元素；参数为两个迭代器，删除两个迭代器之间的元素❤

用法一：list.erase(iterator)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // it指向mylist的第二个元素
    list<int>::iterator it = mylist.begin() + 1;
    // 删除it指向的元素，即2，并返回一个迭代器指向2之后的元素
    list<int>::iterator itnew = mylist.erase(it);
    cout << "\n删除元素后返回的迭代器itnew指向的元素为：" << *itnew;
    cout << "\n使用erase删除元素后：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

用法二：list.erase(iterator1,iterator2)

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // it1指向mylist的第二个元素
    list<int>::iterator it1 = mylist.begin() + 1;
    // it2指向mylist的最后一个元素后一个位置
    list<int>::iterator it2 = mylist.end();

    // 删除[it1,it2)之间的元素,即删除2，3，4
    mylist.erase(it1, it2);
    cout << "\n使用erase删除元素后：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（14） clear()——清空元素

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // 清除mylist中所有元素
    mylist.clear();
    cout << "\n使用erase清空元素后mylist.size() =" << mylist.size();
    cout << "\n使用erase清空元素后：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（15） swap()——交换元素

❤swap的作用就是交换两个list的元素❤

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist1{1, 11, 111, 1111};
    list<int> mylist2{2, 22, 222};
    cout << "初始化后的mylist1为：";
    for (auto num : mylist1) {
        cout << num << " ";
    }
    cout << "\n初始化后的mylist1为：";
    for (auto num : mylist2) {
        cout << num << " ";
    }
    // 交换mylist1和mylist2的元素
    mylist1.swap(mylist2);
    cout << "\n使用swap交换元素后mylist1：";
    for (auto num : mylist1) {
        cout << num << " ";
    }
    cout << "\n使用swap交换元素后mylist2：";
    for (auto num : mylist2) {
        cout << num << " ";
    }
}

📄输出📄

（16） emplace()——插入元素 【C++11】

list用法深度解析，一篇文章弄懂list容器各种操作-LMLPHP

示例如下：

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};
    cout << "初始化后的mylist1为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // it指向mylist第二个元素，即2
    list<int>::iterator it = ++mylist.begin();
    // 向it指向元素(2)前插入元素10，并返回指向10的迭代器
    list<int>::iterator it1 = mylist.emplace(it, 10);
    cout << "\n第一次插入后返回的迭代器it1指向元素为：" << *it1;
    // 向it1指向元素(10)前插入元素20，并返回指向20的迭代器
    list<int>::iterator it2 = mylist.emplace(it1, 20);
    cout << "\n第二次插入后返回的迭代器it2指向元素为：" << *it2;
    // 向mylist尾部插入元素30
    list<int>::iterator it3 = mylist.emplace(mylist.end(), 30);
    cout << "\n第三次插入后返回的迭代器it3指向元素为：" << *it3;
    cout << "\n三次插入元素后，mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（17） emplace_back()——在list尾部插入元素 【C++11】

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};

    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // 在list尾部插入一个元素10
    mylist.emplace_back(10);

    cout << "\n尾部插入一个元素后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（18）emplace_front()——在list头部插入元素 【C++11】

💻示例代码💻

#include <list>
#include <iostream>

using std::cout;
using std::list;
using std::endl;

int main() {
    list<int> mylist{1, 2, 3, 4};

    cout << "初始化后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
    // 在list头部插入一个元素10
    mylist.emplace_front(10);

    cout << "\n头部插入一个元素后的mylist为：";
    for (auto num : mylist) {
        cout << num << " ";
    }
}

📄输出📄

（19） merge()——合并list

注意：merge()方法只能用于已排序的list。如果list未排序，则合并的结果将是不正确的。

用法一：list.merge(list2)
这种方式采用默认的比较函数

💻示例代码💻

#include <iostream>
#include <list>
using namespace std;
int main() {
    std::list<int> list1 = {1, 3, 5};
    std::list<int> list2 = {2, 4, 6};
    cout << "初始化后的list1为：";
    for (auto num : list1) {
        cout << num << " ";
    }
    std::cout << std::endl;
    cout << "初始化后的list2为：";
    for (auto num : list2) {
        cout << num << " ";
    }
    std::cout << std::endl;
    // 将 list2 合并到 list1 中
    list1.merge(list2);
    // 输出合并后的列表
    cout << "合并后的list1为：";
    for (const auto& element : list1) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄输出📄

用法二：list.merge(list2， compareFunction)
这种方式采用自定义的比较函数来合并两个list，compareFunction为自定义的比较函数，示例如下：示例中自定义了一个比较函数，它按照元素模5之后的大小进行比较。

💻示例代码💻

#include <iostream>
#include <list>
using namespace std;
bool customCompare(int x, int y) {
    return x % 5 < y % 5;
}
int main() {
    list<int> list1 = {3, 7, 8, 10, 21};
    list<int> list2 = {5, 6, 9, 13, 18};

    cout << "初始化后的list1为：";
    for (auto num : list1) {
        cout << num << " ";
    }
    std::cout << std::endl;
    cout << "初始化后的list2为：";
    for (auto num : list2) {
        cout << num << " ";
    }
    std::cout << std::endl;

    // 合并两个列表
    list1.merge(list2, customCompare);

    // 输出排序后的结果
    cout << "合并后的list1为：";
    for (int i : list1) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄输出📄

（20） splice()——从另一个list中移动元素

splice共有四种形式，分别为：

  • splice(iterator_pos, otherList) : 将otherList中的所有元素移动到iterator_pos指向元素之前
  • splice(iterator_pos, otherList, iter1): 从 otherList转移 iter1 指向的元素到当前list。元素被插入到 iterator_pos指向的元素之前。
  • splice(iterator_pos, otherList, iter_start, iter_end) : 从 otherList转移范围 [iter_start, iter_end) 中的元素到 当前列表。元素被插入到 iterator_pos指向的元素之前。

注意：

💻示例代码💻

#include <iostream>
#include <list>

int main() {
    std::list<int> list1 = {1, 2, 3, 4, 5};
    std::list<int> list2 = {10, 20, 30};
    std::list<int> list3 = {1, 2, 3, 4, 5};
    std::list<int> list4 = {10, 20, 30};
    std::list<int> list5 = {1, 2, 3, 4, 5};
    std::list<int> list6 = {10, 20, 30};

    /*
       用法一 : splice(iterator_pos, otherList)
    */

    // 将list2中所有元素插入到list1的第一个位置
    list1.splice(list1.begin(), list2);
    // 输出结果
    std::cout<< "转移list2元素到list1之后的list1: ";
    for (int i : list1) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    std::cout<< "转移list2元素到list1之后的list1: ";
    for (int i : list2) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    /*
        用法二：splice(iterator_pos, otherList, iter1)
    */
    auto it = list3.begin();
    // 将迭代器向后移动两个位置，指向第三个元素
    std::advance(it, 2);
    // 将list4的第一个元素(10)插入到list3的第三个位置
    list3.splice(it, list4, list4.begin());
    // 输出结果
    std::cout<< "转移list4元素到list3之后的list3: ";
    for (int i : list3) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    std::cout<< "转移list4元素到list3之后的list4: ";
    for (int i : list4) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    /*
        用法三：splice(iterator_pos, otherList, iter_start, iter_end)
    */
    // 将list5中第二个到第四个元素移动到list6的末尾
    auto first = list5.begin();
    std::advance(first, 1);
    auto last = list5.begin();
    std::advance(last, 4);
    list6.splice(list6.end(), list5, first, last);

    // 输出结果
    std::cout<< "转移list5元素到list6之后的list5: ";
    for (int i : list5) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    std::cout<< "转移list5元素到list6之后的list6: ";
    for (int i : list6) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄初始化的值📄

std::list<int> list1 = {1, 2, 3, 4, 5};
std::list<int> list2 = {10, 20, 30};
std::list<int> list3 = {1, 2, 3, 4, 5};
std::list<int> list4 = {10, 20, 30};
std::list<int> list5 = {1, 2, 3, 4, 5};
std::list<int> list6 = {10, 20, 30};

📄输出📄

（21） remove()——移除特定值的元素

💻示例代码💻

#include <iostream>
#include <list>

int main() {
    std::list<int> mylist {1, 2, 3, 4, 5};
    // 移除列表中所有值为2的元素
    mylist.remove(2);
    std::cout << "移除之后的mylist: ";
    for (const auto& element : mylist) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄输出📄

（21） remove_if()——移除满足特定标准的元素

使用方式：remove_if(func)

💻示例代码💻

#include <iostream>
#include <list>

bool isEven(int n) {
    return n % 2 == 0;
}
int main() {
    std::list<int> mylist {1, 2, 3, 4, 5};
    // 移除列表中所有满足 isEven 的元素（偶数）
    mylist.remove_if(isEven);
    std::cout << "移除之后的mylist: ";
    for (const auto& element : mylist) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄输出📄

（22） reverse()——将该链表的所有元素的顺序反转 【C++11】

💻示例代码💻

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};
    std::cout << "初始化list为: ";
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    myList.reverse();
    std::cout << "Reversed后的list为: ";
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄输出📄

（23） unique()——删除连续的重复元素

💻示例代码💻

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 2, 3, 3, 4, 5, 5, 5};
    std::cout << "初始化后的list为: ";
    for (auto i : myList) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    myList.unique();
    std::cout << "执行unique后的list为: ";
    for (auto i : myList) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄输出📄

（24） sort()——对元素进行排序

💻示例代码💻

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {5, 3, 2, 4, 1};
    std::cout << "初始化后的list为 ";
    for (auto i : myList) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    myList.sort();
    std::cout << "排序后的list为: ";
    for (auto i : myList) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄输出📄

（25） assign()——将值赋给容器

示例如下：

💻示例代码💻

#include <iostream>
#include <vector>
#include <list>

int main() {
    std::list<int> myList;
    // 使用迭代器范围进行分配
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    myList.assign(numbers.begin(), numbers.end());
    std::cout << "第一次执行assign之后的list为: ";
    for (auto i : myList) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    // 使用元素数量和值进行分配
    myList.assign(3, 100);
    std::cout << "第二次执行assign之后的list为: ";
    for (auto i : myList) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

📄输出📄

结语：

欢迎关注🔎点赞👍收藏⭐️留言📝
获取源码，了解更多编程知识，请点击下方名片
list用法深度解析，一篇文章弄懂list容器各种操作-LMLPHP

10-18 19:13
Powered by LMLPHP ©2024 在下马农 0.010430