|
| 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;
提示：通过对一个迭代器的解引用操作（*），可以访问到容器所包含的元素。
|
5583
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
