容器vector和list基本函数

最新推荐文章于 2020-10-20 08:24:54 发布

一生都在写bug

最新推荐文章于 2020-10-20 08:24:54 发布

阅读量409

点赞数 1

本文链接：https://blog.csdn.net/qq495553087/article/details/80915975

版权

vector容器... 1

构造函数... 1

运算符... 1

assign函数... 2

at函数... 2

begin-end 函数... 2

capacity 函数... 3

clear 函数... 3

empty 函数... 3

erase 函数... 3

front-back 函数... 4

? get_allocator 函数... 4

insert 函数... 4

max_size 函数... 4

pop_back. 4

push_back 函数... 5

rbegin 函数... 5

rend 函数... 5

reserve 函数... 5

resize 函数... 5

size 函数... 6

swap 函数... 6

补充：remove_if（）... 6

list7

构造函数：... 7

赋值(assign)7

front-back. 8

begin-end. 8

clear8

empty. 8

erase. 8

? get_allocator9

insert9

max_size. 9

merge. 9

pop_back-pop_front10

push_front -push_back. 10

? rbegin-rend. 10

remove. 10

? remove_if10

resize. 11

reverse. 11

size. 11

sort11

splice. 11

swap. 12

unique. 12

vector容器

构造函数

语法:

vector <string> v1(10,"a"); //创建类型为srting的容器，个数为10，内容为a，内容数量可省略

vector <string> v2(v1); //创建一个和V1一样的容器

vector <string> v3{"a","b","c","d"}; //创建一个容器且，全部初始化

vector <string> v4; //创建一个空白容器

vector <string>::iterator itr; //创建一个指向的迭代器

vector <string> v5(v1.begin(),v1.end()-8,v1.get_allocator()); //创建一个容器，使用开始和结尾的地址

vector <int> v6(10,6);

C++ Vectors可以使用以下任意一种参数方式构造:

无参数 - 构造一个空的vector,

数量(num)和值(val) - 构造一个初始放入num个值为val的元素的Vector

vector(from) - 构造一个与vector from 相同的vector

迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间).

运算符

语法:

v1 == v2

v1 != v2

v1 <= v2

v1 >= v2

v1 < v2

v1 > v2

v[]

C++ Vectors能够使用标准运算符: ==, !=, <=, >=,<, 和 >. 要访问vector中的某特定位置的元素可以使用 [] 操作符.

两个vectors被认为是相等的,如果:

它们具有相同的容量

所有相同位置的元素相等.

vectors之间大小的比较是按照词典规则. （a>A）

assign函数

语法:

v4.assign(v2.begin(),v2.end());

//assign会从后面的指针中从头到尾的复制数据

v4.assign(1,"d");

//会从第一个位置复制制定个数的元素

assign() 函数要么将区间[start, end)的元素赋到当前vector,或者赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值以前的内容.

at函数

语法:

cout << "v2 = " << v2.at(i) << endl;

//at(i)会指向第i个位置的值，比直接a[i]安全。at()有边界保护

at() 函数返回当前Vector指定位置loc的元素的引用. at() 函数比 [] 运算符更加安全, 因为它不会让你去访问到Vector内越界的元素.

begin-end 函数

语法:

for(itr = v1.begin();itr != v1.end();itr++) //使用迭代器指向v1，然后开启循环

{ //begin()指向起始元素的地址

cout << "vi = " << *itr << endl; //end()指向vector末尾元素的下一位置，

*itr += 65; //注意,如果你要访问末尾元素,需要先将此迭代器自减1.

cout << "vi = " << *itr << endl; //使用字符串会在值后面再加一个数值，数值等于加的值，使用int不会

}

begin()函数返回一个指向当前vector起始元素的迭代器.

end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.注意,如果你要访问末尾元素,需要先将此迭代器自减1.

capacity 函数

语法:

v4.capacity();

//返回当前vector在重新进行内存分配以前所能容纳的元素数量.

capacity() 函数返回当前vector在重新进行内存分配以前所能容纳的元素数量.

clear 函数

语法:

v4.clear();

//删除当前vector中的所有元素.

clear()函数删除当前vector中的所有元素.

empty 函数

语法:

b = v4.empty();

cout << "v4.empty? " << b << endl;

//判断容器是否为空，为空返回1，否则返回0

如果当前vector没有容纳任何元素,则empty()函数返回true,否则返回false.例如,以下代码清空一个vector,并按照逆序显示所有的元素:

while( !v.empty() ) {

cout << v.back() << endl;

v.pop_back();

}

erase 函数

语法:

v3.erase(v3.begin(),v3.end()-3); //删除指定区间的数值

v3.erase(itr = v3.begin()); //删除制定位置的数值

erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元素的下一位置的迭代器.

front-back 函数

语法:

cout << "v3.front = " <<v3.front() << endl; //front()会指向起始位置的数值

cout << "v3.end = " << v3.back() << endl; //back()会指向最后位置的数值

front()函数返回当前vector起始元素的引用

back() 函数返回当前vector最末一个元素的引用

? get_allocator 函数

语法:

allocator_type get_allocator();

get_allocator() 函数返回当前vector的内存分配器.

insert 函数

语法:

v5.insert(v5.begin(),"qw"); //在某一位置前插入一个数值，

v5.insert(v5.end(),3,"w"); //在某一位置前插入n个位置

v5.insert(v5.begin(),v1.begin(),v1.end()); //在某一位置前插入另一一段地址的所有值

insert() 函数有以下三种用法:

在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,

在指定位置loc前插入num个值为val的元素

在指定位置loc前插入区间[start,end)的所有元素 .

max_size 函数

语法:

int a = v1.max_size(); //最大的可能的元素个数.

max_size() 函数返回当前vector所能容纳元素数量的最大值(译注:包括可重新分配内存).

pop_back

语法:

v5.pop_back(); //删除最后一个元素

pop_back()函数删除当前vector最末的一个元素, vector<char>alphaVector;

push_back 函数

语法:

v5.push_back("a"); //在最后面插入一个值

push_back()添加值为val的元素到当前vector末尾

rbegin 函数

语法:

reverse_iterator rbegin();

rbegin函数返回指向当前vector末尾的逆迭代器.(译注:实际指向末尾的下一位置,而其内容为末尾元素的值)

rend 函数

语法:

cout << *v6.rend()-1 <<endl;

//返回指向当前vector末尾的逆迭代器,实际指向末尾的下一位置,而其内容为末尾元素的值

rend()函数返回指向当前vector起始位置的逆迭代器.

reserve 函数

语法:

v6.reserve(10);

//当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)

reserve()函数为当前vector预留至少共容纳size个元素的空间.(注:实际空间可能大于size)

resize 函数

语法:

v6.resize(18,10000);

//扩充为制定大小，但是不能比resize小，

resize() 函数改变当前vector的大小为size,且对新创建的元素赋值val

size 函数

语法:

for(i = 0;i < v5.size() ;i++)

//size() 函数返回当前vector所容纳元素的数目

size() 函数返回当前vector所容纳元素的数目

swap 函数

语法:

v5.swap(v1);

//交换两个容器的数值

swap()函数交换当前vector与vector from的元素

补充：remove_if（）

本质上还是调用了rease，remove_if是将要删除的东西排到后面，并指向第一个删除的位置

list

list是一个能够存放任意型别的双向链表

构造函数：

string arr[3] = {"abc","bcd","efg"};

list <string> L1; //创建一个空的list链表

list <string> L2(10); //创建一个元素个数为10的list链表

list <string> L3(10,"abc"); //创建一个元素个数为10的，内容为“abc”的list链表

list <string> L4(L3); //创建一个和L3一样的list链表

list <string> L5(arr,arr+3); //利用数组创建一个的list链表

list <string>::iterator itr; //创建一个迭代器

赋值(assign)

语法:

L2.assign(L3.begin(), L3.end()); //利用L3给L2赋值

L2.assign(6,"a"); //给链表从开始位置赋n个值,会覆盖之前数值

assign()函数以迭代器start和end指示的范围为list赋值或者为list赋值num个以val为值的元素。

front-back

语法:

cout << "L5.front = " << L5.front() << endl; //指向最开始的元素

cout << "L5.back = " << L5.back() << endl; //指向最末尾的元素

front()函数返回一个引用，指向链表的第一个元素。

back()函数返回一个引用，指向list的最后一个元素。

begin-end

语法:

cout << "L2 = "; //给链表从开始位置赋n个值,会覆盖之前数值

for( itr = L2.begin(); itr != L2.end(); itr++ ) //迭代器begin指向链表开始地址

cout << *itr << " "; //迭代器end指向链表末尾地址

begin()函数返回一个迭代器，指向list的第一个元素。

end()函数返回一个迭代器，指向链表的末尾(并不是最后一个元素)。

clear

语法:

L5.clear(); //清空列表

clear()函数删除list的所有元素。

empty

语法:

cout << "L5 = empty? " << L5.empty() <<endl;

//判断链表是否为空，为空返回1，不空返回0

erase

语法:

L5.erase(L5.begin()); //删除某一个位置的数值

L5.erase(L5.begin(),L5.begin()end ); //删除从begin到end的数值

erase()函数删除以pos指示位置的元素, 或者删除start和end之间的元素。返回值是一个迭代器，指向最后一个被删除元素的下一个元素。

? get_allocator

语法:

allocator_type get_allocator();

get_allocator()函数返回链表的配置器。

insert

语法:

L5.insert(L5.begin(),"start"); //指定位置插入一个数值

L5.insert(L5.begin(),6,"qwer"); //指定位置插入N个数值

L5.insert(L5.begin(),L4.begin(),L4.end ); //指定位置插入另外一个链表的数值

insert()插入元素val到位置pos，或者插入num个元素val到pos之前，或者插入start到end之间的元素到pos的位置。返回值是一个迭代器，指向被插入的元素。

max_size

语法:

cout << "L5.max_size() = " << L5.max_size() << endl; //返回可存储的最大个数

max_size()函数返回链表能够储存的元素数目。

merge

语法:

L5.merge(L4); //将L4和L5排列成一个链表。L4在前 L5.merge( L4, Comp compfunction );

merge()函数把自己和lst链表连接在一起，产生一个整齐排列的组合链表。如果指定compfunction，则将指定函数作为比较的依据。

pop_back-pop_front

语法:

L5.pop_front(); //删除最开始位置的元素

L5.pop_back(); //删除最末尾位置的元素

pop_back()函数删除链表的最后一个元素。

pop_front()函数删除链表的第一个元素。

push_front -push_back

语法:

L5.push_front("new-start"); //在最前端加数值

L5.push_back("end"); //在末尾加数值

push_front()函数将val连接到链表的头部。

push_back()将val连接到链表的最后

? rbegin-rend

语法:

cout << "*L5.rbegin() = " << *L5.rbegin(); //L5.rbgin指向链表末尾

L5.rend() //指向L5开头，起始之前

rbegin()函数返回一个逆向迭代器，指向链表的末尾。

remove

语法:

L5.remove("abc"); //删除指定数值

remove()函数删除链表中所有值为val的元素。例如

? remove_if

语法:

void remove_if( UnPred pr );

remove_if()以一元谓词pr为判断元素的依据，遍历整个链表。如果pr返回true则删除该元素。

resize

语法:

L5.resize(10,"q"); //给L5重新分配可存储大小

resize()函数把list的大小改变到num。被加入的多余的元素都被赋值为val，可以省略val

reverse

语法:

L5.reverse(); //反转链表中元素位置

reverse()函数把list所有元素倒转。

size

语法:

cout << "L5.size = " << L5.size() << endl; //返回链表中元素个数

size()函数返回list中元素的数量。

sort

语法:

L5.sort(); //链表中元素排序

sort()函数为链表排序，默认是升序。如果指定compfunction的话，就采用指定函数来判定两个元素的大小。

splice

语法:

L5.splice(L5.end(),L2); //在指定位置连上另外一个链表

void splice( iterator pos, list &lst, iterator del );

void splice( iterator pos, list &lst, iterator start, iterator end );

splice()函数把lst连接到pos的位置。如果指定其他参数，则插入lst中del所指元素到现链表的pos上，或者用start和end指定范围。

swap

语法:

L2.swap(L5); //交换两个链表的数值

swap()函数交换lst和现链表中的元素。

unique

语法:

L2.unique(); //删除重复元素

void unique( BinPred pr );

unique()函数删除链表中所有重复的元素。如果指定pr，则使用pr来判定是否删除。

一生都在写bug

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
容器vector和list基本函数

目录 vector容器... 1 构造函数... 1 运算符... 1 assign函数... 2 at函数... 2 begin-end 函数... 2 capacity 函数... 3 clear 函数... 3 empty 函数... 3 erase 函数... 3 front-back 函数... 4 ? get_allocator 函数... 4 insert 函数... 4 max_...
复制链接

扫一扫