|
| vector(向量容器)的基本使用入门： |
| 简介 |
vector 的特点：
(1) 指定一块如同数组一样的连续存储，但空间可以动态扩展。即它可以像数组 一样操作，并且可以进行动态操作。通常体现在push_back() pop_back() 。
(2) 随机访问方便，它像数组一样被访问，即支持[ ] 操作符和vector.at()
(3) 节省空间，因为它是连续存储，在存储数据的区域都是没有被浪费的，但是 要明确一点vector 大多情况下并不是满存的，在未存储的区域实际是浪费的。
(4) 在内部进行插入、删除操作效率非常低，这样的操作基本上是被禁止的。 Vector 被设计成只能在后端进行追加和删除操作，其原因是vector 内部的实现 是按照顺序表的原理。
(5) 只能在vector 的最后进行push 和pop ，不能在vector 的头进行push 和pop 。
(6) 当动态添加的数据超过vector 默认分配的大小时要进行内存的重新分配、拷 贝与释放，这个操作非常消耗性能。 所以要vector 达到最优的性能，最好在创 建vector 时就指定其空间大小。 Vectors 包含着一系列连续存储的元素,其行为和数组类似。访问Vector中的 任意元素或从末尾添加元素都可以在常量级时间复杂度内完成，而查找特定值的 元素所处的位置或是在Vector中插入元素则是线性时间复杂度。
基本方法：
1.at() 返回指定位置的元素
语法：
TYPE at( size_type loc );
//差不多等同v[i];但比v[i]安全;
2.back() 返回最末一个元素
3.begin() 返回第一个元素的迭代器
4.capacity() 返回vector所能容纳的元素数量(在不重新分配内存的情况下）
5.clear() 清空所有元素
6.empty() 判断Vector是否为空（返回true时为空）
7.end() 返回最末元素的迭代器(译注:实指向最末元素的下一个位置)
8.erase() 删除指定元素
语法：
iterator erase( iterator loc );
//删除loc处的元素
iterator erase( iterator start, iterator end );
//删除start和end之间的元素
9.front() 返回第一个元素的引用
10.get_allocator() 返回vector的内存分配器
11.insert() 插入元素到Vector中
语法： iterator insert( iterator loc, const TYPE &val ); //在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器, void insert( iterator loc, size_type num, const TYPE &val ); //在指定位置loc前插入num个值为val的元素 void insert( iterator loc, input_iterator start, input_iterator end ); //在指定位置loc前插入区间[start, end)的所有元素
12.max_size() 返回Vector所能容纳元素的最大数量（上限）
13.pop_back() 移除最后一个元素
14.push_back() 在Vector最后添加一个元素
15.rbegin() 返回Vector尾部的逆迭代器
16.rend() 返回Vector起始的逆迭代器
17.reserve() 设置Vector最小的元素容纳数量 //为当前vector预留至少共容纳size个元素的空间
18.resize() 改变Vector元素数量的大小
语法:
void resize( size_type size, TYPE val ); //改变当前vector的大小为size,且对新创建的元素赋值val
19.size() 返回Vector元素数量的大小
20.swap() 交换两个Vector 语法： void swap( vector &from )
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
#define _CRT_SECURE_NO_WARNINGS#include <iostream>#include <vector>using namespace std;struct Teacher{ char name[20]; int age;};void printfA(vector<int> &tmp){ int size = tmp.size(); for (int i = 0; i < size;i++) { cout << tmp[i] <<","; if (i+1==size) { cout << endl; } }}void main(){ //vector是一个模板类 在使用模板类的时候需要指明具体的类型 vector<int>v1(5); //相当于int v1[5] //赋值打印 cout << "vector赋值打印:" << endl; for (int i = 0; i < 5;i++) { v1[i] = i + 1; cout << v1[i] << endl; } //类做函数参数 vector<int>v2(20); v2 = v1; cout << "类做函数参数:" << endl; printfA(v2); vector<int>v3(20); v3.push_back(100);//push_back会在类结尾进行添加新的数值,并且会将前面的二十个元素进行初始化 printfA(v3); //初始化Teacher结构体 Teacher t1, t2; t1.age = 10; strcpy(t1.name, "张锋"); t2.age = 20; strcpy(t2.name, "柴宇婷"); //声明一个Teacher类型的vector模板类 vector<Teacher> vTeacher(5); vTeacher[0] = t1; vTeacher[1] = t2; cout <<"Teacher类型的vector模板："<< vTeacher[0].age << "---" << vTeacher[2].age << endl; //v声明一个 Teacher * 类型的vector模板类 vector<Teacher *> vTeacherPoint(5); vTeacherPoint[0] = &t1; vTeacherPoint[1] = &t2; cout << "打印指针类型vector:" << endl; int vTeacherPointSize = vTeacherPoint.size(); for (int i = 0; i < vTeacherPointSize; i++) { Teacher *temp = vTeacherPoint[i]; if (temp != NULL) { cout << "第" << i + 1 << "个老师的年龄为：" << temp->age << " 名字为：" << temp->name << endl; } } system("pause");} |
|
|
stack(栈)的基本使用入门：
|
|
简介
|
C++ Stack（堆栈） 是一个容器类的改编，为程序员提供了堆栈的全部功能，— —也就是说实现了一个先进后出（FILO）的数据结构。
1.empty() 堆栈为空则返回真
2.pop() 移除栈顶元素
3.push() 在栈顶增加元素
4.size() 返回栈中元素数目
5.top() 返回栈顶元素
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
#include <iostream>#include <stack>using namespace std;struct Teacher{ int age; char name[20];};void printfStack(stack<int> &tmp){ while (!tmp.empty ()) { cout << tmp.top() << endl; tmp.pop(); }}void main(){ //声明一个stack类型的容器 stack<int> s1; //栈是先进后出 //循环添加元素 for (int i = 0; i < 5; i++) { s1.push(i + 1); } //1.0通过指针做函数参数进行传参 cout << "通过指针调用 演示：" << endl; printfStack(s1); //2.0遍历站内元素 while (!s1.empty ()) { cout << s1.top() << endl;//获取栈顶元素 s1.pop();//弹出栈顶元素 } //3.0放Teacher cout << "Teacher 演示：" << endl; stack<Teacher> sTeacher; Teacher t; for (int i = 0; i < 5;i++) { t.age = i+20; sTeacher.push(t); } while (!sTeacher.empty ()) { cout << sTeacher.top().age << endl; sTeacher.pop(); } //4.0放Teacher * cout << "Teacher * 演示：" << endl; stack<Teacher *> sTeacherPoint; Teacher t1,t2,t3; t1.age = 20; t2.age = 21; t3.age = 22; sTeacherPoint.push(&t1); sTeacherPoint.push(&t2); sTeacherPoint.push(&t3); while (!sTeacherPoint.empty ()) { //Teacher * tmp = sTeacherPoint.top(); cout << sTeacherPoint.top()->age << endl; sTeacherPoint.pop(); } system("pause");} |
|
|
Queues(队列)的基本使用入门：
|
|
简介
|
C++队列是一种容器适配器，它给予程序员一种先进先出(FIFO)的数据结构。
1.back() 返回一个引用，指向最后一个元素
2.empty() 如果队列空则返回真
3.front() 返回第一个元素
4.pop() 删除第一个元素
5.push() 在末尾加入一个元素
6.size() 返回队列中元素的个数
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
#include <iostream>#include <queue>using namespace std;struct Teacher{ int age; char name[20];};void printfQueue(queue<Teacher> &tmp){ while (!tmp.empty()) { cout << tmp.front().age << endl; tmp.pop(); }}void main(){ //1.0定义一个queue容易 cout << "基础演示 ：" << endl; queue<int> q; for (int i = 0; i < 5; i++) { q.push(i + 1); } int size = q.size(); for (int i = 0; i < size; i++) { cout << q.front() << endl; q.pop(); } //2.0放Teacher cout << "Teacher 演示：" << endl; queue<Teacher> qTeacher; Teacher t; for (int i = 0; i < 2;i++) { t.age = 21 + i; qTeacher.push(t); } printfQueue(qTeacher); //4.0放Teacher * cout << "Teacher * 演示：" << endl; queue<Teacher *> qTeacherPoint; Teacher t1, t2, t3; t1.age = 20; t2.age = 21; t3.age = 22; qTeacherPoint.push(&t1); qTeacherPoint.push(&t2); qTeacherPoint.push(&t3); while (!qTeacherPoint.empty()) { //Teacher * tmp = sTeacherPoint.top(); cout << qTeacherPoint.front()->age << endl; qTeacherPoint.pop(); } system("pause");} |
|
|
list(双向链表)的基本使用入门：
|
| 简介 |
是一个线性链表结构，它的数据由若干个节点构成，每一个节点都包括一个 信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定 的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指 针将有序的元素链接起来。
由于其结构的原因，list 随机检索的性能非常的不好，因为它不像vector 那 样直接找到元素的地址，而是要从头一个一个的顺序查找，这样目标元素越靠后， 它的检索时间就越长。检索时间与目标元素的位置成正比。 虽然随机检索的速度不够快，但是它可以迅速地在任何节点进行插入和删除 操作。因为list 的每个节点保存着它在链表中的位置，插入或删除一个元素仅对 最多三个元素有所影响，不像vector 会对操作点之后的所有元素的存储地址都有 所影响，这一点是vector 不可比拟的。
list 的特点：
(1) 不使用连续的内存空间这样可以随意地进行动态操作；
(2) 可以在内部任何位置快速地插入或删除，当然也可以在两端进行push和pop 。
(3) 不能进行内部的随机访问，即不支持[ ] 操作符和vector.at() ；
Lists将元素按顺序储存在链表中，与向量(vectors)相比，它允许快速的插入 和删除，但是随机访问却比较慢.
|
|
用法
|
1.assign() 给list赋值
2.back() 返回最后一个元素的引用
3.begin() 返回指向第一个元素的迭代器
4.clear() 删除所有元素
5.empty() 如果list是空的则返回true
6.end() 返回末尾的迭代器
7.erase() 删除一个元素 语法： iterator erase( iterator loc );//删除loc处的元素 iterator erase( iterator start, iterator end ); //删除start和end之间的元素
8.front() 返回第一个元素的引用
9.get_allocator() 返回list的配置器
10.insert() 插入一个元素到list中 语法： iterator insert( iterator loc, const TYPE &val ); //在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器, void
insert( iterator loc, size_type num, const TYPE &val ); //定位置loc前插入num个值为val的元素 void insert( iterator loc, input_iterator start, input_iterator end ); //在指定位置loc前插入区间[start, end)的所有元素
11.max_size() 返回list能容纳的最大元素数量
12.merge() 合并两个list 语法: void merge( list &lst );//把自己和lst链表连接在一起 void merge( list &lst, Comp compfunction ); //指定compfunction，则将指定函数作为比较的依据。
13.pop_back() 删除最后一个元素
14.pop_front() 删除第一个元素
15.push_back() 在list的末尾添加一个元素
16.push_front() 在list的头部添加一个元素
17.rbegin() 返回指向第一个元素的逆向迭代器
18.remove() 从list删除元素 语法: void remove( const TYPE &val ); //删除链表中所有值为val的元素
19.remove_if() 按指定条件删除元素
20.rend() 指向list末尾的逆向迭代器
21.resize() 改变list的大小 语法: void resize( size_type num, TYPE val ); //把list的大小改变到num。被加入的多余的元素都被赋值为val22.
22.reverse() 把list的元素倒转
23.size() 返回list中的元素个数
24.sort() 给list排序 语法: void sort();//为链表排序，默认是升序 void sort( Comp compfunction );//采用指定函数compfunction来判定两个元素的大小。
25.splice() 合并两个list 语法: void splice( iterator pos, list &lst );//把lst连接到pos的位置 void splice( iterator pos, list &lst, iterator del );//插入lst中del所指元素到现链表的pos上 void splice( iterator pos, list
&lst, iterator start, iterator end );//用start和end指定范围。
26.swap() 交换两个list 语法： void swap( list &lst );// 交换lst和现链表中的元素
27.unique() 删除list中重复的元素 语法: void unique();//删除链表中所有重复的元素 void unique( BinPred pr );// 指定pr，则使用pr来判定是否删除。
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
#include <iostream>#include <list>using namespace std;struct Teacher{ int age; char name[20];}; void main (){ //1.0定义list容器 list<int> l; for (int i = 0; i < 5; i++) { l.push_back(i + 1); } cout <<"list数量："<< l.size() << endl; //2.0定义一个迭代器 指向第一个元素 list<int>::iterator cur = l.begin(); while (cur!=l.end ()) { cout << *cur << endl; cur++; } //3.0插入元素 cout << "------------插入一个元素------------" << endl; cur = l.begin(); cur++; cur++; l.insert(cur, 100); for (list<int>::iterator p = l.begin(); p != l.end();p++) { cout << *p << endl; } //4.0list放Teacher cout << "------------list放Teacher------------" << endl; list<Teacher> lTeacher; Teacher t1, t2; t1.age = 10; t2.age = 20; lTeacher.push_back(t1); lTeacher.push_back(t2); for (list<Teacher>::iterator p = lTeacher.begin(); p != lTeacher.end(); p++) { cout << p->age << endl; } //5.0list放Teacher * cout << "------------list放Teacher *------------" << endl; list<Teacher *> lTeacherPoint; lTeacherPoint.push_back(&t1); lTeacherPoint.push_back(&t2); for (list<Teacher *>::iterator p = lTeacherPoint.begin(); p != lTeacherPoint.end();p++) { Teacher *tmp = *p; cout << tmp->age << endl; } system("pause");} |
|
迭代器：
|
|
迭代器是一种对象，它能够用来遍历STL容器中的部分或全部元素，每个迭 代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口，所谓迭代器 是一种概念上的抽象：那些行为上象迭代器的东西都可以叫做迭代器。然而迭代 器有很多不同的能力，它可以把抽象容器和通用算法有机的统一起来。
迭代器提供一些基本操作符：*、++、==、！ =、=。这些操作和C/C++“操作 array元素”时的指针接口一致。不同之处在于，迭代器是个所谓的smart pointers， 具有遍历复杂数据结构的能力。其下层运行机制取决于其所遍历的数据结构。因 此，每一种容器型别都必须提供自己的迭代器。事实上每一种容器都将其迭代器 以嵌套的方式定义于内部。因此各种迭代器的接口相同，型别却不同。这直接导 出了泛型程序设计的概念：所有操作行为都使用相同接口，虽然它们的型别不同。
迭代器使开发人员不必整个实现类接口。只需提供一个迭代器，即可遍历类 中的数据结构，可被用来访问一个容器类的所包函的全部元素，其行为像一个指 针，但是只可被进行增加(++)或减少(--)操作。举一个例子，你可用一个迭代器 来实现对vector容器中所含元素的遍历。 如下代码对vector容器对象生成和使用了迭代器：
vector<int> the_vector; vector<int>::iterator the_iterator; for (int i = 0; i < 10; i++) the_vector.push_back(i); int total = 0; the_iterator = the_vector.begin(); while (the_iterator != the_vector.end()) { total += *the_iterator; the_iterator++; } cout << "Total=" << total << endl;提示：通过对一个迭代器的解引用操作（*），可以访问到容器所包含的元素。
|
扫一扫
1928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
