C++容器之list

最新推荐文章于 2022-08-13 17:30:16 发布
最新推荐文章于 2022-08-13 17:30:16 发布
阅读量2.4k 收藏 5
点赞数
分类专栏： C++ 文章标签： c++ 容器 list iterator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tj807126663/article/details/26137161
版权

简介

         List是一种可在常数时间内在任何位置执行插入和删除操作的顺序容器。list是双向链表，其迭代器是双向的。与其他顺序容器(array, vector, deque)相比，list容器在任意位置执行插入、提取、和移动元素的操作更高效，但它不能通过在容器中的位置直接获取元素。

成员函数

复制控制

list::list()

         构造函数：构造一个新的list对象，根据参数初始化list容器的内容。

list::~list()

         析构函数：销毁以list对象。

list::operator=

         为容器分配新的内容，代替当前的内容，随之修改其大小。

示例代码

#include<iostream>
#include<list>
 
using namespace std;
 
void
print(list<int> l)
{
    for(list<int>::iterator it = l.begin(); it != l.end(); ++it)
    {
       cout << *it << "";
    }
    cout << endl;
}
 
int
main(void)
{
    // list::list()
    list<int> first;
    list<int> second(5, 10);
    list<int> third(second.begin(), second.end());
    list<int> fourth(third);
    int arr[] = {1, 2, 3, 4, 5};
    list<int> fifth(arr, arr + sizeof(arr)/sizeof(int));
    print(second);
    print(third);
    print(fourth);
    print(fifth);
   
    // list::operator=
    first = fifth;
    print(first);
   
    return(0);
}

Iterator

list::begin()

         返回一个迭代器，指向list的第一个元素。返回值类型:iterator/const_iterator。

list::end()

         返回一个迭代器，指向list的最后一个元素的下一个位置。返回值类型:iterator/const_iterator。

list::rbegin()

        返回一个反转迭代器，指向list的最后一个元素。返回值类型:reverse_iterator/reverse_const_iterator。

list::rend()

         返回一个反转迭代器，指向list的第一个元素的前一个位置。返回值类型:reverse_iterator/reverse_const_iterator。

list::cbegin()

         begin()的const版本。

list::cend()

         end()的const版本

list::crbegin()

         rbegin()的cosnt版本。

list::crend()

         rend()的const版本。

示例代码

#include <iostream>
#include <list>

using namespace std;

int
main(void)
{
	int arr[] = {1, 2, 3, 4, 5};
	list<int> l(arr, arr + sizeof(arr)/sizeof(int));
	
	// list::begin end
	for(list<int>::iterator it = l.begin(); it != l.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	
	// list::rbegin rend
	for(list<int>::reverse_iterator it = l.rbegin(); it != l.rend(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	
	// list::cbegin cend
	for(list<int>::const_iterator it = l.cbegin(); it != l.cend(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	
	// list::cbegin cend
	for(list<int>::const_reverse_iterator it = l.crbegin(); it != l.crend(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	
	return 0;
}

Capacity

list::empty()

         测试list是否为空，空返回true，否则返回false。

list::size()

         返回list中元素个数。返回值类型list::size_type。

list::max_size()

         返回list能够容纳元素的最大个数。返回值类型list::size_type。

示例代码

 

#include<iostream>
#include<list>
 
using namespace std;
 
int
main(void)
{
    list<int> l(10, 20);
   
    // list::empty
    if(l.empty()){
       cout << "Listis empty" << endl;
    }else{
       cout << "Listis not empty" << endl;
    }
   
    cout << "Listsize : " << l.size() << endl;
    cout << "Listmax size : " << l.max_size() << endl;
   
    return(0);
}

Element access

list::front()

         返回list第一个元素的引用。返回值类型reference/const_reference。

list::back()

         返回list最后一个元素的引用。返回值类型reference/const_reference。

示例代码

#include<iostream>
#include<list>
 
using namespace std;
 
int
main(void)
{
    int arr[] = {1, 2, 3, 4, 5};
    list<int> l(arr, arr + sizeof(arr)/sizeof(int));
   
    // list::front
    cout << "Thefirst element is : " << l.front() << endl;
    // list::back
    cout << "Thesecond element is : " << l.back() << endl;
 
    return(0);
}

Modifiers

list::assign()

         为list分配新的内容，以代替当前内容，并随之改变其大小。

list::emplace_front()

        在list的前端插入一个元素。插入的元素由其构造函数创建。

list::push_front()

         在list的前端插入一个元素。与emplace_front()不同，它的插入方式是将一个已存在的元素复制或移动到list前端。

list::pop_front()

         删除list的第一个元素。

list::emplace_back()

         在list的末端插入一个元素。插入的元素由其构造函数创建。

list::push_back()

         在list的末端插入一个元素。与emplace_back()不同，它的插入方式是将一个已存在的元素复制或移动到list末端。

list::pop_back()

         删除list的最后一个元素。

list::emplace()

         在指定位置插入一个元素。插入的元素由其构造函数创建。

list::insert()

         在指定位置插入一个或多个元素。对于插入大量元素来说是非常高效的。

list::erase()

         从list中删除指定位置的一个或一定范围的元素。

list::swap()

         交换两个list中的元素。两个list类型必须相同，大小可以不同。

list::resize()

         重新分配list的大小，使其能容纳指定数量的元素。

list::clear

         删除list中的所有元素。

示例代码

#include<iostream>
#include<list>
#include<vector>
 
using namespace std;
 
void
print(list<int> l)
{
    for(list<int>::iterator it = l.begin(); it != l.end(); ++it)
    {
       cout << *it << "";
    }
    cout << endl;
}
 
int
main(void)
{
    list<int> first;
    list<int> second;
    list<int> third;
    int arr[] = {1, 2, 3, 4, 5};
   
    // list::assign
    first.assign(5, 10);
    second.assign(first.begin(), first.end());
    third.assign(arr, arr + sizeof(arr)/sizeof(int));
    print(first);
    print(second);
    print(third);
   
    // list::emplace emplace_front emplace_back
    list<pair<int, char>> pl;
    pl.emplace_front(1, 'a');
    pl.emplace_front(2, 'b');
    pl.emplace_back(3, 'c');
    pl.emplace(pl.end(), 4, 'd');
    for(pair<int, char> x :pl)
    {
        cout<< x.first << "" << x.second << endl;
    }
   
    //list::push_front push_back
    third.push_front(10);
    third.push_back(20);
    print(third);
   
    // list::insert
    first.insert(first.begin(), 20);
    first.insert(first.end(), 2, 30);
    vector<int> vec(2, 40);
    first.insert(first.end(), vec.begin(), vec.end());
    print(first);
   
    // list::erase
    second.erase(second.begin());
    print(second);
    second.erase(++second.begin(), second.end());
    print(second);
   
    // list::swap
    second.swap(first);
    print(first);
    print(second);
   
    // list::resize
    third.resize(5);
    print(third);
    third.resize(10);
    print(third);
    third.resize(15, 100);
    print(third);
   
    // list::clear
    third.clear();
    cout << "Thesize of third is : " << third.size() << endl;
 
    return(0);
}

Operations

list::splice()

         将一个list A中的元素转移到list B的指定位置，并将A中被转移的元素删除。

list::remove()

         将list中指定的元素删除。

list::remove_if()

         根据判断条件删除list的元素，如果条件为真则删除该元素。

list::unique()

         删除list中具有相同值的元素，只保留第一个。也可以根据条件删除具有相同条件的元素，只保留第一个。

list::merge()

         合并两个list，在合并之前两个list应该先排序，合并之后的list依然有序。也可以自定义排序的条件。

list::sort()

         对list中的元素进行排序，变更它们在容器中的位置。sort()还可以按给定条件进行排序。

list::reverse()

         改变list中元素的顺序。

示例程序

#include<iostream>
#include<cmath>
#include<list>
 
using namespace std;
 
void
print(list<int> l)
{
    for(list<int>::iterator it = l.begin(); it != l.end(); ++it)
    {
       cout << *it << "";
    }
    cout << endl;
}
 
bool
single_dight(const int &val)
{
    return val > 10;
}
 
bool
is_near(int first, int second)
{
    return(fabs(first - second) < 5);
}
 
bool
reverse(int first, int second)
{
    return((first -second) > 0);
}
 
int
main(void)
{
    list<int> first(2, 10);
    list<int> second(2, 20);
    list<int>::iteratorit;
   
    // list::splice
    it = first.begin();
    first.splice(it, second);
    print(first);
    if(second.empty())
    {
       cout << "Secondis empty" << endl;
    }
    else
    {
       cout << "Secondis not empty" << endl;
    }
    // it still point to 10(the 3th element)
    cout << *it << endl;
    second.splice(second.begin(), first, it);
    print(second);
   
    it = first.begin();
    advance(it, 2);
    print(first);
    first.splice(first.begin(), first, it, first.end());
    print(first);
   
    // list::remove
    cout << "Beforeremove : ";
    print(first);
    first.remove(10);
    cout << "Afterremove : ";
    print(first);
   
    // list::remove_if
    cout << "Beforeremove_if : ";
    first.push_back(10);
    print(first);
    first.remove_if(single_dight);
    cout << "Afterremove_if : ";
    print(first);
   
    // list::unique
    first.push_back(20);
    first.push_back(20);
    first.push_back(21);
    cout << "Beforecall unique() : ";
    print(first);
    first.unique();
    cout << "Aftercall unique() : ";
    print(first);
   
    cout << "Beforecall unique() : ";
    print(first);
    first.unique(is_near);
    cout << "Aftercall unique() : ";
    print(first);
   
    // list::merge
    first.push_back(5);
    first.push_back(12);
    first.sort();
    print(first);
    second.push_back(9);
    second.push_back(17);
    second.sort();
    print(second);
   
    first.merge(second);
    print(first);
   
    // list::sort
    first.sort(reverse);
    print(first);
   
    // list::reverse
    first.reverse();
    print(first);
    return(0);
}


tj807126663
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++深拷贝和浅拷贝
qq_33287871的博客
08-14 149
深拷贝和浅拷贝 1 浅拷贝 同一类型的对象之间可以赋值，使得两个对象的成员变量的值相同，两个对象仍然是独立的两个对象，这种情况被称为浅拷贝. 一般情况下，浅拷贝没有任何副作用，但是当类中有指针，并且指针指向动态分配的内存空间，析构函数做了动态内存释放的处理，会导致内存问题。 2 深拷贝 当类中有指针，并且此指针有动态分配空间，析构函数做了释放处理，往往需要自定义拷贝构造函数，自行给指针动态分配空间，深拷贝。 class Person{ public: Person(char* name,
listCtrl自绘控件（C++）
07-31
自绘型listCtrl控件，其中实现了内嵌Combobox控件（下拉框），edit控件，以及button控件。无需修改，粘贴复制即可使用。
复制容器list中部分元素到另一个list中 C++
weixin_40132776的博客
10-15 2839
简单记录一下 #include <iostream> #include <list> int main(int argc,char* argv[]) { int arr[]={12,34,23,54,56,32,56}; std::list<int> mylist(arr,arr+7); std::list<int> mylistCopy; std::list<int> ::iterator it; f
STL-容器间的复制list&vector
beattwo的专栏
06-10 331
[code="c++"] #include #include #include #include int main() { //copy list to list std::list oldList; std::list newList; oldList.push_back("test1"); oldList.push_back("test2"); ...
STL之四：list用法详解
热门推荐
longshengguoji的专栏
01-19 2万+
list容器介绍 相对于vector容器的连续线性空间，list是一个双向链表，它有一个重要性质：插入操作和删除操作都不会造成原有的list迭代器失效，每次插入或删除一个元素就配置或释放一个元素空间。也就是说，对于任何位置的元素插入或删除，list永远是常数时间。 常用函数 (1)    构造函数 list c:创建一个空的list list c1(c2):复制另一个同类型元素的list
C++ STL详解(三) ------- list
向未来❀去探索 的博客
08-13 680
C++ STL详解(三) ------- list
List容器
m0_46376834的博客
05-27 232
这里写目录标题List 容器概念list头尾的添加移除操作list的数据存取list与迭代器list的赋值list的大小list的插入list的删除 List 容器概念 list是一个双向链表容器，可高效地进行插入删除元素。 List 特点： list不可以随机存取元素，所以不支持at.(position)函数与[]操作符。可以对其迭代器执行++，但是不能这样操作迭代器：it+3 使用时包含 #include list对象的默认构造 list同样采用模板类实现,对象的默认构造形式：list li
List的浅拷贝和深拷贝
yuemingxingxing的博客
12-12 247
浅拷贝 1、遍历循环复制 List<Person> destList = new ArrayList<Person>(srcList.size()); for(Person p : srcList){ destList.add(p); } 2、使用List实现类的构造方法 List<Person> destList = new ...
如何复制list
gaoyan601的博客
11-07 1537
在java中，对list的操作会直接影响和它有关系任何其他变量。分为两种情况 1. 如：有两个list   List a = new ArralyList(); List b = new ArralyList(); 如果简单的进行a=b,那么在稍后的操作中，对b进行任何操作，a都会受影响，如执行b.clear()，那么a也会被clear掉。 2. 存在两个list
List Copy
qq_35434142的博客
07-14 323
Copying array to Listusing System; using System.Collections.Generic; class Program { staticvoid Main() { int[] arr = newint[3]; // New array with 3 elements arr[0] = 2;
C++实现STL容器之List
最新发布
04-08
C++实现STL容器之List
C++语言 STL容器list总结
01-21
在使用std::list<>链表时，难免会对数据进行添加删除操作。而遍历链表则有两种方式：通过索引访问，象数组一样处理；通过std::list<>::iterator链表遍历器进行访问 STL 中的list 就是一 双向链表，可高效地...
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
c++中容器之总结篇
12-31
C++中的容器大致可以分为两个大类：顺序容器和关联容器。顺序容器中有包含有顺序容器适配器。 顺序容器：将单一类型元素聚集起来成为容器，然后根据位置来存储和访问这些元素。主要有vector、list、deque（双端队列...
C++容器之forward_list
tj807126663的专栏
06-03 4979
简介          Forward_list是一种能在常数时间内在任何位置插入和删除的顺序容器。Forward_list是单向链表。          Forward_list和list的区别在于前者是单向链表，在内部元素只有一个链接到下一个元素，它的迭代器是前向有效的；后者是双向链表，在内部存在两个链接，一个链接指向下一个元素，另一个链接指向前面一个元素，它的迭代器是双向有效地，在存储方
C++容器之Queue
tj807126663的专栏
06-09 3473
简介          Queue是一种容器适配器，它专门设计用于元素执行先进先出操作。元素在容器的一端插入，在另一端取出。          Queue作为容器适配器而实现，它是一个使用指定容器类作为其潜在容器存储数据，并提供一组操作函数对容器中的数据进行操作的类。          潜在容器可以是标准容器类模板或者是一些特殊设计过的容器类，它们必须提供如下操作： Ø  front()
C++容器之Priority queue
tj807126663的专栏
06-10 1714
简介          Priorityqueue是一种容器适配器，它的第一个元素始终是容器中的最大值。          Priorityqueue作为容器适配器而实现，它是一种使用指定的容器类作为其潜在的容器存储元素，并提供一组元素操作函数的类。          Priorityqueue的潜在容器可以是标准容器类，也可以是通过特殊设计的容器类。这些容器类必须满足能随机访问且支持如下操
C++容器之vector
tj807126663的专栏
04-28 906
简介 vector是C++标准库的一部分
C++ list 容器
11-27
C++中的list是一个序列式容器，本质上是一个双向链表。它可以在常数时间复杂度内进行插入和删除操作，但是随机访问元素的时间复杂度为线性。以下是一个简单的C++ list容器的例子： ```cpp #include #include <list...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值