2017-03-19 21:26:36 qq_35040828 阅读数 498
  • c++入门到精通教程 c++11/14/17

    本教程适合那些只有一点点c语言编程知识的新手,也适合那些c++98标准已经掌握的不错但对c++11/14/17新标准基本无所知的c++开发老手,欢迎大家尽早加入学习,请大家从授课目录,讲解课程时长、演示范例详尽程度,试听后收获四个方面评估本教程的质量。

    7313 人正在学习 去看看 王健伟

在std::list中删除一个元素非常简单,直接使用erase方法即可,代码如下:

for(iter = list.begin(); iter != list.end();) {
if (shouldDelete(*iter))
iter = list.erase(iter);
else
++iter;
}

或者更简单点

list.erase(std::remove_if(list.begin(), list.end(), shouldDelete), list_end());

然而根据STL std::map中的定义void erase(iterator pos),此erase并不返回下一个元素的迭代器,因此不能采用std::list的方法

The truth is that ‘erase’ in associative containers doesn’t invalidate any iterators except those that point to elements being erased (that’s also true for ’sid::list’). For this reason, you don’t really need ‘map::erase’ to return an iterator. Just do this

for(iter = map.begin(); iter != map.end();) {
if (shouldDelete(*iter))
map.erase(iter++);
else
++iter;
}

当然此方法同样也适合于std::list等

2017-08-24 11:40:36 zhanghaizhe 阅读数 1448
  • c++入门到精通教程 c++11/14/17

    本教程适合那些只有一点点c语言编程知识的新手,也适合那些c++98标准已经掌握的不错但对c++11/14/17新标准基本无所知的c++开发老手,欢迎大家尽早加入学习,请大家从授课目录,讲解课程时长、演示范例详尽程度,试听后收获四个方面评估本教程的质量。

    7313 人正在学习 去看看 王健伟

 c++ stl list将元素按顺序储存链表中. 与 向量(vectors)相比, 它允许快速的插入和删除,但是随机访问却比较慢.c++ STL List就是一双向链表,可高效地进行插入删除元素。包括构造、方法等。

    c++ STL List构造方法

list<int> c0; //空链表

list<int> c1(3); //建一个含三个默认值是0的元素的链表

list<int> c2(5,2); //建一个含五个元素的链表,值都是2

list<int> c4(c2); //建一个c2的copy链表

list<int> c5(c1.begin(),c1.end()); ////c5含c1一个区域的元素[_First, _Last)。


    c++ STL List其它成员方法:

assign()给list赋值

back()返回最后一个元素

begin()返回指向第一个元素的迭代器

clear()删除所有元素

empty()如果list是空的则返回true

end()返回末尾的迭代器

erase()删除一个元素

front()返回第一个元素

get_allocator()返回list的配置

insert()插入一个元素到list中

max_size()返回list能容纳的最大元素数量

merge()      合并两个list

pop_back()删除最后一个元素

pop_front()删除第一个元素

push_back()在list的末尾添加一个元素

push_front()在list的头部添加一个元素

rbegin()返回指向第一个元素的逆向迭代器

remove()从list删除元素

remove_if()按指定条件删除元素

rend()  指向list末尾的逆向迭代器

resize()改变list的大小

reverse()把list的元素倒转

size()返回list中的元素个数

sort()给list排序

splice()合并两个list

swap()交换两个list

unique()删除list中重复的元素


c++ STL List具体用法举例


list对象的声明构造():

A.      list<int>c0;                 //空链表

B.      list<int>c1(3);             //建一个含三个默认值是0的元素的链表

C.      list<int>c2(5,2);            //建一个含五个元素的链表,值都是2

D.      list<int>c4(c2);             //建一个c2的copy链表

E.       list<int>c5(c1.begin(),c1.end());  

//c5含c1一个区域的元素[_First, _Last)。

1.       assign()分配值,有两个重载:

c1.assign(++c2.begin(), c2.end()) //c1现在为(50,60)。

c1.assing(7,4)  //c1中现在为7个4,c1(4,4,4,4,4,4,4)。

2.       back()返回最后一元素的引用

int i=c1.back();  //i=30

const int i=c2.back();  //i=60且不可修改

3.       begin()返回第一个元素的指针(iterator)

citer=c1.begin();    // *citer=10

list<int>::const_iterator cciter=c1.begin(); //*cciter=10且为const。

4.       clear()删除所有元素

c1.clear();   //c1为空  c1.size为0;

5.       empty()判断是否链表为空

bool B=c1.empty(); //若c1为空B=true;否则B=false;

6.       end()返回最后一个元素的下一位置的指针(list为空时end()=begin())

citer=c1.end(); //*(--citer)=30;

同begin()返回一个常指针,不能修改其中元素。

7.       erase()删除一个元素或一个区域的元素(两个重载)

c1.erase(c1.begin()); // c1现为(20,30);

c1.erase(++c1.begin(),c1.end()); // c1现为(10);

8.       front() 返回第一个元素的引用:

int i=c1.front(); //i=10;

const int i=c1.front(); //i=10且不可修改。

9.       insert()在指定位置插入一个或多个元素(三个重载):

c1.insert(++c1.begin(),100);   //c1(10,100,20,30)

c1.insert(c1.begin(),2,200);  //c1(200,200,20,30);

c1.insert(++c1.begin(),c2.begin(),--c2.end());

//c1(10,40,50,20,30);

10.    max_size()返回链表最大可能长度(size_type就是int型):

list<int>::size_type i=c1.max_size();  //i=1073741823

11.    merge()合并两个链表并使之默认升序(也可改):

c2.merge(c1);   //c1现为空;c2现为c2(10,20,30,40,50,60)

c2.merge(c1,greater<int>()); //同上,但c2现为降序

12.    pop_back()删除链表尾的一个元素

c1.pop_back()  //c1(10,20);

13.    pop_front()删除链表头的一元素

c1.pop_front() //c1(20,30)

14.    push_back()增加一元素到链表尾

c1.push_back(100) //c1(10,20,30,100)

15.    push_front()增加一元素到链表头

c1.push_front(100) //c1(100,10,20,30)

16.    rbegin()返回链表最后一元素的后向指针(reverse_iterator or const)

list<int>::reverse_iterator riter=c1.rbegin(); //*riter=30

17.    rend()返回链表第一元素的下一位置的后向指针

list<int>::reverse_iterator riter=c1.rend(); // *(--riter)=10

18.    remove()删除链表中匹配值的元素(匹配元素全部删除)

c1.remove(10);     //c1(20,30)

19.    remove_if()删除条件满足的元素(会遍历一遍链表)

c1.remove_if( is_odd<int> () ); //c1(10,20,30) 

//is_odd自己写(表奇数) 

20.    resize()重新定义链表长度(两重载):

c1.resize(4)  //c1(10,20,30,0)用默认值填补

c1.resize(4,100) //c1(10,20,30,100)用指定值填补

21.    reverse()反转链表:

c1.reverse(); //c1(30,20,10)

22.    size()返回链表中元素个数

list<int>::size_type i=c1.size();  //i=3

23.    sort()对链表排序,默认升序(可自定义)

c1.sort();  //c1(10,20,30)

c1.sort(great<int>()); //c1(30,20,10)

24.    splice()对两个链表进行结合(三个重载)

c1.splice(++c1.begin(),c2);

//c1(10,40,50,60,20,30) c2为空 全合并

c1.splice(++c1.begin(),c2,++c2.begin());

//c1(10,50,20,30) ; c2(40,60) 指定元素合并

c1.splice(++c1.begin(),c2,++c2.begin(),c2.end());

//c1(10,50,60,20,30); c2(40) 指定范围合并

25.    swap()交换两个链表(两个重载)

c1.swap(c2);  //c1(40,50,60);

swap(c1,c2);  //c1(40,50,60)

26.    unique()删除相邻重复元素(断言已经排序,因为它不会删除不相邻的相同元素)

c1.unique();

//假设c1开始(-10,10,10,20,20,-10)则之后为c1(-10,10,20,-10)

c1.unique(mypred); //自定义谓词

2019-07-27 08:45:31 weixin_44545509 阅读数 438
  • c++入门到精通教程 c++11/14/17

    本教程适合那些只有一点点c语言编程知识的新手,也适合那些c++98标准已经掌握的不错但对c++11/14/17新标准基本无所知的c++开发老手,欢迎大家尽早加入学习,请大家从授课目录,讲解课程时长、演示范例详尽程度,试听后收获四个方面评估本教程的质量。

    7313 人正在学习 去看看 王健伟

C++ List 容器

开发工具与关键技术:Visual Studio、C++
作者:张国军
撰写时间:2019年07月25日

list 是一个双向链表容器,可高效地进行插入删除元素。
list 不可以随机存取元素,所以不支持 at.(pos)函数与[]操作符。
使用list之前需要引用头文件:#include
//list 采用采用模板类实现, 对象的默认构造形式:list lstT; 如:
list lstInt; //定义一个存放 int 的 list 容器。
list lstFloat; //定义一个存放 float 的 list 容器。
list lstString; //定义一个存放 string 的 list 容器。
list 的赋值

#include  <iostream>
#include <list>
using  namespace std;
void stackshow(list<int>& s)
{
	for (list<int>::iterator it = s.begin(); it != s.end();it++)
	{
		cout << *it<<" ";
	}
	cout << endl;
}
void main()
{
	//list.assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
	//注意该区间是左闭右开的区间。
	//list.assign(n, elem); //将 n 个 elem 拷贝赋值给本身。
	//list& operator=(const list &lst); //重载等号操作符
	//list.swap(lst); //将 lst 与本身的元素互换。
	list<int> lstIntA, lstIntB, lstIntC, lstIntD;
	lstIntA.push_back(1);
	lstIntA.push_back(3);
	lstIntA.push_back(5);
	lstIntA.push_back(7);
	lstIntA.push_back(9);
	lstIntB.assign(lstIntA.begin(), lstIntA.end()); //1 3 5 7 9
	lstIntC.assign(5, 8); //8 8 8 8 8
	lstIntD = lstIntA; //1 3 5 7 9
	lstIntC.swap(lstIntD);//将lstIntC容器元素和lstIntD容器元素交换
	cout << "----------lstIntA-----------"<<endl;
	stackshow(lstIntA);
	cout << "----------lstIntB-----------"<<endl;
	stackshow(lstIntB);
	cout << "----------lstIntC-----------"<<endl;
	stackshow(lstIntC);
	cout << "----------lstIntD-----------"<<endl;
	stackshow(lstIntD);
}

在这里插入图片描述
list 头尾的添加移除操作

void main()
{
	//list.push_back(elem); //在容器尾部加入一个元素
	//list.pop_back(); //删除容器中最后一个元素
	//list.push_front(elem); //在容器开头插入一个元素
	//list.pop_front(); //从容器开头移除第一个元素
	list<int> lstInt;
	lstInt.push_back(1);
	lstInt.push_back(3);
	lstInt.push_back(5);
	lstInt.push_back(7);
	lstInt.push_back(9);
	lstInt.pop_front();
	cout << "pop_front 1"<<endl;
	stackshow(lstInt);
	lstInt.pop_front();
	cout << "pop_front 2"<<endl;
	stackshow(lstInt);
	lstInt.push_front(11);
	cout << "push_front(11)"<<endl;
	stackshow(lstInt);
	lstInt.push_front(13);
	cout << "push_front(13)" << endl;
	stackshow(lstInt);
	lstInt.pop_back();
	cout << "pop_back() 1" << endl;
	stackshow(lstInt);
	lstInt.pop_back();
	cout << "pop_back() 2" << endl;
	stackshow(lstInt);
}

在这里插入图片描述

c++ list
2019-06-14 14:01:37 qq_29339467 阅读数 1564
  • c++入门到精通教程 c++11/14/17

    本教程适合那些只有一点点c语言编程知识的新手,也适合那些c++98标准已经掌握的不错但对c++11/14/17新标准基本无所知的c++开发老手,欢迎大家尽早加入学习,请大家从授课目录,讲解课程时长、演示范例详尽程度,试听后收获四个方面评估本教程的质量。

    7313 人正在学习 去看看 王健伟

c++ list头文件

简介

  • list实际上是双向链表,故亦可称之为doubly-linked list
  • 性质
    • 双向
    • 链表

双向

  • 双向即给定一个元素,我们能够知道后一个元素和前一个元素
  • list的迭代器是双向迭代器

链表

  • 优点:与向量(vectors)相比,它可以快速的插入和删除–插入和删除操作是常数时间的
  • 缺点:随机访问比较慢–元素的访问不是常数时间的,获取元素往往需要在给定一个迭代器的基础上来通过遍历实现
    时间复杂度
    • 常数时间O(1)(与输入数据无关): 基本操作重复执行的次数是一个固定的常数,执行次数不存在变化,通俗的讲就是:无论n是什么值运算所花时间都一样
    • 线性时间O(n)(与输入数据成正比): 基本操作重复执行的次数是与模块n成线性相关的,其值会随着模块n的变化而变化,当模块n的规模确定为定值后,其时间复杂度转化为O(1)

List

定义和初始化

  • listlst1; // 创建空list
  • listlst2(6); //创建含有6个元素的list
  • listlst3(3, 2); // 创建含有三个元素的list
  • listlst4(lst2); // 使用ls2初始化ls4
  • listlst5(lst2.begin(), lst2.end()); // 同ls4

list常用操作函数

  • lst1.assign() // 给list赋值
  • lst1.front() // 返回第一个元素
  • lst1.back() // 返回最后一个元素
  • lst1.begin() // 返回指向第一个元素的迭代器
  • lst1.end() // 返回末尾的迭代器
  • lst1.insert() // 插入一个元素到list中
  • lst1.erase() // 删除一个元素
  • lst1.pop_back() // 删除最有一个元素
  • lst1.pop_front() // 删除第一个元素
  • lst1.clear() // 删除所有元素
  • lst1.remove(const T & val) // 删除和val相等的元素
  • lst1.push_back() // 在list的末尾添加一个元素
  • lst1.push_front() // 在list的首部添加一个元素
  • lst1.empty() // 判断,若list为空返回true
  • lst1.max_size() // 返回list能容纳的最大元素数量
  • lst1.sort() // 给list排序(顺序)
  • list.reverse() // 把list中的元素倒转
  • lst1.merge(lst2) // 合并lst2到lst1,并清空lst2
  • lst1.unique() // 删除所有和前一个元素相等的元素
  • void splice(iterator i, list & x, iterator first, iterator last) // 在位置i前面插入链表x中的区间 [first, last), 并在链表x中删除该区间(链表自身和链表x可以是用一个链表,只要i不在 [first, last) 中即可

list案例

#include <list>  // 使用 list 需要包含此头文件
#include <algorithm>  // 使用 STL 中的算法需要包含此头文件
#include <iostream>  
using namespace std;

class A
{
public:
	A(int n_):n(n_){}
	friend bool operator < (const A & a1, const A & a2);
	friend bool operator == (const A & a1, const A & a2);
	friend ostream & operator << (ostream & out, const A & a);
private:
	int n;
};

bool operator < (const A & a1, const A & a2){
	return a1.n < a2.n;
}

bool operator == (const A & a1, const A & a2){
	return a1.n == a2.n;
}

ostream & operator << (ostream & out, const A & a){
	out << a.n;
	return out;
}
template <class T>
void Print(T first, T last)
{
	for(; first != last; ++first)
		cout<<*first<<" ";
	cout<<endl;
}

int main()
{
	A a[5] = {1, 3, 2, 4, 2};
	A b[7] = {10, 30, 20, 30, 30, 40, 40};
	list<A> lst1(a, a+5), lst2(b, b+7);
	lst1.sort();    // 顺序排序
	cout<<"1. "; Print(lst1.begin(), lst1.end());
	lst1.remove(2);  // 删除所有和A(2)相等的元素
	cout<<"2. "; Print(lst1.begin(), lst1.end());
	lst2.pop_front();  // 删除第一个元素
	cout<<"3. "; Print(lst2.begin(), lst2.end());
	lst2.unique();  // 删除所有和前一个元素相等的元素
	cout<<"4. "; Print(lst2.begin(), lst2.end());
	lst2.sort();  // 顺序排序
	lst1.merge(lst2);  // 合并 lst2 到 lst1 并清空 lst2
	cout<<"5. "; Print(lst1.begin(), lst1.end());
	cout<<"6. "; Print(lst2.begin(), lst2.end());  // lst2 是空的
	lst1.reverse();  // 将 lst1 倒置

	cout<<"7. "; Print(lst1.begin(), lst1.end());
	lst2.insert(lst2.begin(), a + 1, a + 4);  // 在 lst2 中插入 3,2,4 三个元素
	list<A>::iterator p1, p2, p3;
	p1 = find(lst1.begin(), lst1.end(), 30);  // 查找元素
	p2 = find(lst2.begin(), lst2.end(), 2);
	p3 = find(lst2.begin(), lst2.end(), 4);
	lst1.splice(p1, lst2, p2, p3);  // 将 [p2, p3) 插入p1之前,并从lst2中删除 [p2, p3)
	cout<<"8. "; Print(lst1.begin(), lst1.end());
	cout<<"9. "; Print(lst2.begin(), lst2.end());
	return 0;  
}
1. 1 2 2 3 4
2. 1 3 4
3. 30 20 30 30 40 40
4. 30 20 30 40
5. 1 3 4 20 30 30 40
6.
7. 40 30 30 20 4 3 1
8. 40 2 30 30 20 4 3 1
9. 3 4
请按任意键继续. . .

【实例】用 list 解决约瑟夫问题

约瑟夫问题是:有 n 只猴子,按顺时针方向围成一圈选大王(编号为 1~n),从第 1 号开始报数,一直数到 m,数到 m 的猴子退到圈外,剩下的猴子再接着从 1 开始报数。就这样,直到圈内只剩下一只猴子时,这个猴子就是猴王。编程求输入 n、m 后,输出最后猴王的编号。

输入数据:每行是用空格分开的两个整数,第一个是 n,第二个是 m(0<m, n<=1 000 000)。最后一行是:
0 0

输出要求:对于每行输入数据(最后一行除外),输出数据也是一行,即最后猴王的编号。

输入样例:
6 2
12 4
8 3
0 0

输出样例:
5
1
7

程序如下

#include <list>
#include <iostream>
using namespace std;

int main()
{
	list<int> monkeys;
	int n, m;
	while(1)
	{
		cin >> n >> m;
		if(n == 0 && m == 0)
			break;
		monkeys.clear();  // 清空list容器
		for(int i = 0; i <= n; ++ i)  // 将猴子的编号放入list中
			monkeys.push_back(i);
		list<int>::iterator it = monkeys.begin();  // 定义一个迭代器
		while(monkeys.size() > 1)  // 只要还有不止一只猴子,就要找一只猴子让其出列
		{
				for(int i = 1; i < m; ++ i)  // 报数
			{
				++it;
				if(it == monkeys.end())
					it = monkeys.begin();
			}
			it = monkeys.erase(it);  // 删除元素后,迭代器失效
			                         // 要重新让迭代器指向被删元素的后面
			if(it == monkeys.end())
				it = monkeys.begin();
		}
		cout<<monkeys.front()<<endl;  // front返回第一个元素的引用
	}
	return 0;
}
10000 3
2694
0 0
请按任意键继续. . .

erase 成员函数返回被删除元素后面那个元素的迭代器,如果被删除的是最后一个元素,则返回end()

2016-01-24 14:24:17 LIQIANGEASTSUN 阅读数 2331
  • c++入门到精通教程 c++11/14/17

    本教程适合那些只有一点点c语言编程知识的新手,也适合那些c++98标准已经掌握的不错但对c++11/14/17新标准基本无所知的c++开发老手,欢迎大家尽早加入学习,请大家从授课目录,讲解课程时长、演示范例详尽程度,试听后收获四个方面评估本教程的质量。

    7313 人正在学习 去看看 王健伟

C++ list 使用方法

使用 list需引入头文件#include <list>

引入命名空间 using namespace std;

list函数如下

//assign()      给list赋值
//back()        返回最后一个元素的引用
//begin()       返回指向容器第一个元素的指针
//clear()       删除所有元素
//empty()       如果list是空的则返回true
//end()         返回容器末尾的指针
//erase()       删除一个元素
//front()       返回第一个元素
//get_allocator() 返回list的配置器
//insert()      插入一个元素到容器中
//max_size()    返回list能容纳的最大元素数量
//merge()       合并两个list
//pop_back()    删除最后一个元素
//pop_front()   删除第一个元素
//push_back()   在list的末尾添加一个元素
//push_front()  在list的头部添加一个元素
//rbegin()      返回指向第一个元素的逆向迭代器
//remove()      从list删除元素
//remove_if()   按指定条件删除元素
//rend()        指向list末尾的逆向迭代器
//resize()      改变list的大小
//reverse()     把list的元素倒转
//size()        返回list中的元素个数
//sort()        给list排序
//splice()      合并两个list
//swap()        交换两个list
//unique()      删除list中重复的元素

使用实例如下

// Pro1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <list>

using namespace std;

// 创建一个 list 容器的实例 intList
typedef list<int> intList;

bool Is2(int i);

bool Sort(int i, int j);

int main()
{
    intList _intList;

    for (int i = 0; i < 3; ++i)
    {
        // 在容器头部添加一个元素
        _intList.push_front(i);
    }

    for (int i = 0; i < 3; ++i)
    {
        // 在容器末尾添加一个元素
        _intList.push_back(i * 10);
    }

    // 获取容器存储元素的个数
    int size = _intList.size();
    std::cout << "size : " << size <<endl;  // size : 6

    // 获取容器可以存储的最大元素个数 
    int max_size = _intList.max_size();
    std::cout << "max_size : " << max_size << endl;   // max_size : 357913941

    // 声明 it 为容器迭代器
    intList::iterator it;

    // 获取指向容器第一个元素的指针
    //_intList.begin()

    // 获取指向容器最后一个元素 +1 的指针
    // _intList.end()

    // 使用迭代器遍历容器
    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;  // 2, 1, 0, 0, 10, 20
    }

    // front()获取容器第一个元素的引用
    int n = _intList.front();
    std::cout << "n  : "<< n << endl;  // n  : 2

    // front() 作为第一个元素的引用,可以作为左值使用 
    _intList.front() = 111;
    n = _intList.front();
    std::cout << "n  : " << n << endl;  // n  : 111

    // back() 返回最后一个元素的引用
    n = _intList.back();
    std::cout << "n  : " << n << endl;  // n  : 20

    // back() 作为最后一个元素的引用,可以作为左值使用
    _intList.back() = 222;
    n = _intList.back();
    std::cout << "n  : " << n << endl;  // n  : 222

    // 使用迭代器遍历容器
    it = _intList.begin();
    for (; it != _intList.end();)
    {
        // 删除一个元素
        _intList.erase(it++);
    }

    size = _intList.size();
    std::cout << "size : " << size << endl;  // size : 0

    // 在容器第一个元素位置插入数据 1,返回迭代器 it 位置处的指针
    it = _intList.begin();
    it = _intList.insert(it, 1);
    ++it;
    // 在迭代器 it 位置插入数据 2
    it = _intList.insert(it, 2);

    // 在迭代器 it 位置插入 2 个数据 3
    it = _intList.insert(it, 2, 3);

    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 1, 3, 3, 2
    }

    std::cout << "" << endl;   
    // 
    it = _intList.begin();
    // 在_intList.begin()位置开始,插入++it和_intList.end() 之间的数据
    _intList.insert(_intList.begin(), ++it, _intList.end());

    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 3, 3, 2, 1, 3, 3, 2
    }

    // 删除容器第一个元素
    _intList.pop_front();
    // 删除容器最后一个元素
    _intList.pop_back();

    // 删除容器所有元素
    _intList.clear();
    size = _intList.size();
    std::cout << "size : " << size << endl;  // size : 0

    // 判断容器是否为空
    if (_intList.empty())
    {
        std::cout << "_intList is empty" << endl;
    }

    for (int i = 0; i < 3; i ++)
    {
        _intList.insert(it, i);
        _intList.insert(it, i);
    }

    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 0, 0, 1, 1, 2, 2,
    }

    std::cout << "" << endl;   // 0, 0, 1, 1, 2, 2,

    // 删除容器中所有值为 1 的元素
    _intList.remove(1);
    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 0, 0, 2, 2,
    }

    std::cout << "" << endl;

    // 删除容器中符合 函数 Is2 返回 true 的值
    _intList.remove_if(Is2);
    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 0, 0,
    }

    std::cout << "" << endl;

    // 改变容器存储空间大小(可以存储元素个数)
    _intList.resize(10);
    // 改变容器存储空间大小,新添加数据默认填充 100
    _intList.resize(10, 100);

    _intList.clear();

    for (int i = 0; i < 5; i++)
    {
        _intList.push_back(i);
    }

    // 将容器中的数据反转
    _intList.reverse();

    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 4, 3, 2, 1, 0
    }

    std::cout << "" << endl;

    _intList.push_back(0);

    // 删除容器中重复的元素
    _intList.unique();

    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 4, 3, 2, 1, 0
    }

    // 将容器中数据按照 Sort 函数排序
    _intList.sort(Sort);
    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 4, 3, 2, 1, 0
    }
    std::cout << "" << endl;

    intList _intList2;

    _intList2.push_back(100);
    _intList2.push_back(200);
    _intList2.push_back(300);

    // 将容器 _intList2容器合并到 _intList
    _intList.merge(_intList2);
    for (it = _intList.begin(); it != _intList.end(); ++it)
    {
        std::cout << *it << endl;   // 0, 1, 2, 3, 4, 100, 200, 300
    }

    // _intList2 数据已清空
    size = _intList2.size();
    std::cout << "size : "<< size << endl;   // size : 0

    std::cout << "" << endl;


    system("pause");
    return 0;
}

bool Is2(int i)
{
    return i == 2;
}

bool Sort(int i, int j)
{
    return i < j;
}

运行结果

这里写图片描述

这里写图片描述

C++ STL list

阅读数 291

没有更多推荐了,返回首页