【C++】STL和vector容器

STL和vector容器

• 基本概念
• 六大组件
• • 容器
  • 算法
  • 迭代器
  • 容器算法迭代器
• vector容器
• • 基本概念
  • vector构造函数
  • 赋值
  • vector的容量和大小
  • vector插入与删除
  • vector存取数据
  • • 函数原型
  • vector互换容器
  • vector预留空间
  • vector容器嵌套容器

基本概念

长久以来，软件届一直希望建立一种可重复利用的东西，C++的面向对象和泛型编程思想，目的就是复用性的提升，大多情况下，数据结构和算法都未能有一套标准，导致被迫从事大量重复工作，为了建立数据结构和算法的一套标准，诞生了STL。STL称标准模板库 ，从广义上分为容器（container）、算法（algorithm）、迭代器（iterator） ，容器 和算法 之间通过迭代器进行无缝连接，STL几乎所有的代码都采用了模板类或者模板函数。

六大组件

1、容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据。

2、算法：各种常用的算法，如sort、find、copy、for_each等

3、迭代器：扮演了容器与算法之间的胶合剂

4、仿函数：行为类似函数，可作为算法的某种策略

5、适配器：一种用来修饰容器或者仿函数或迭代器接口的东西

6、空间配置器：负责空间的配置与管理

容器

放置物品的地方，STL容器就是将运用最广泛的一些数据结构实现出来。常用的数据结构：数组、链表、树、栈、队列、集合、映射表等。这些容器分为序列式容器和关联式容器两种，序列式容器，强调值的排序，序列式容器中的每个元素均有固定的位置；关联式容器，二叉树结构，各元素之间没有严格的物理上的顺序关系。

算法

问题的解法，有限的步骤，解决逻辑或数学上的问题叫做算法。算法分为质变算法和非质变算法。质变算法，是指运算过程中会更改区间内的元素的内容，例如拷贝、替换、删除等；非质变算法，是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等。

迭代器

容器和算法之间的粘合剂，提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式，每个容器都有自己专属的迭代器，迭代器使用非常类似于指针，初学阶段可以理解为指针。

常用的容器中迭代器种类为双向迭代器和随机访问迭代器。

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读，支持++、==、！=
输出迭代器	对数据的只写访问	只写，支持++
前向迭代器	读写操作，并能向前推进迭代器	读写，支持++、==、！=
双向迭代器	读写操作，并能向前或向后操作	读写，支持++
随机访问迭代器	读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器	读写，支持++、--、[n]、-n、<、<=、>、>=

容器算法迭代器

在例子中体现

例：迭代器：vector<int>::iterator

vector容器

基本概念

功能：vector数据结构和数组非常相似，也称单端数组

vector与普通数组区别：不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。

vector容器的迭代器是支持随机访问的迭代器。

vector构造函数

创建vector容器

1、vector<T> v;采样模板实现类实现，默认构造函数

2、vector（v.begin(),v.end()）; 将**v[begin(),end()）**区间中的元素拷贝给本身

3、vector（n，elem）; 构造函数将n个elem拷贝给本身

4、vector（const vector &vec）; 拷贝构造函数

void test1() {
	vector<int> v1;//默认构造
	for (int i = 0;i < 5;i++) {
		v1.push_back(i);
	}
	p(v1);
	cout << endl;
	vector<int> v2(v1.begin(), v1.end());
	p(v2);
	cout << endl;
	vector<int>v3(5, 100);
	p(v3);
	cout << endl;
	vector<int>v4(v3);
	p(v4);
	cout << endl;
}

赋值

1、vector& operator=（const vector &vec）；重载等号操作符

2、assign（beg，end）；将[beg,end)区间中的数据拷贝赋值给本身

3、assign（n，elem）；将n个elem拷贝给本身

void test1() {
	vector<int> v1;
	for (int i = 0;i < 5;i++) {
		v1.push_back(i);
	}

	p(v1);
	vector<int> v2;
	v2 = v1;
	p(v2);
	vector<int>v3;
	v3.assign(v1.begin(), v1.end());
	p(v3);
	vector<int>v4;
	v4.assign(5, 100);
	p(v4);
}

vector的容量和大小

1、empty();判断容器是否为空

2、capacity();容器的容量

3、size();返回容器中元素的个数

4、resize(int num);重新指定容器的长度为num，若容器变长，则以默认值0填充新位置；若容器变短，则末尾超出容器长度的元素被删除

5、resize(int num,elem);重新指定容器的长度为num，若容器变长，则以elem值填充新位置；若容器变短，则末尾超出容器长度的元素被删除

void test1() {
	vector<int> v1;
	for (int i = 0;i < 5;i++) {
		v1.push_back(i);
	}

	if (v1.empty()) {
		cout << "为空" << endl;
	}
	else {
		cout << "bu为空" << endl;
		cout << "容量：" <<v1.capacity()<< endl;
		cout << "大小：" << v1.size() << endl;
	}
	v1.resize(10,100);
	p(v1);
	v1.resize(4);
	p(v1);
}

vector插入与删除

1、push_back(ele);尾部插入元素ele

2、pop_back（）；删除最后一个元素

3、insert（const_iterator pos，ele）；迭代器指向位置pos插入元素ele

4、insert（const_iterator pos，int count，ele）；迭代器指向位置pos插入count个元素ele

5、erase（const_iterator pos）；删除迭代器指向的元素

6、erase（const_iterator start，const_iterator end）；删除迭代器从start到end之间的元素

7、clear();删除容器中的所有元素

void test1() {
	vector<int> vi;
	for (int i = 0;i < 10;i++) {
		vi.push_back(i * 10);
	}
	vi.pop_back();
	vector<int>::iterator it = vi.begin();
	for (it;it != vi.end();it++) {
		cout << *it << "\t";
	}
	vi.clear();
	cout << endl;
	cout << "清空后vi的个数" << vi.size() << endl;
	vi = { 1,2,3,4,5 };
	vi.insert(vi.begin(), 10);
	vi.insert(vi.begin() + 1, 60);
	vi.erase(vi.begin() + 2);
	vi.erase(vi.begin() + 3, vi.begin() + 5);
	vi.push_back(100);
	p(vi);
}

vector存取数据

存放内置数据类型可以查看：STL常用一些函数

算法：for_each

迭代器：vector<int>::iterator

函数原型

1、at（int index）；返回索引index所指的数据

2、opterator[];返回索引index所指的数据

3、front();返回容器中第一个数据元素

4、back();返回容器中最后一个数据元素

class S {
public:
	int age;
	string name;
	S(string _n, int _a) {
		name = _n;
		age = _a;
	}
};
void test() {
	vector<int> vi;
	for (int i = 0;i < 10;i++) {
		vi.push_back(i * 10);
	}

	cout << "第一个元素" << vi.front() << endl;
	cout << "第一个元素" << vi.back() << endl;
}
void test1() {
	//存放指针（自定义类型数据）
	vector<S *> v;
	S s1("lisi", 18);
	S s2("Laola", 20);
	S s3("Tom", 23);
	S s4("Tony", 35);
	S s5("Qi", 24);
	v.push_back(&s1);
	v.push_back(&s2);
	v.push_back(&s3);
	v.push_back(&s4);
	v.push_back(&s5);
	for (vector<S *>::iterator i = v.begin();i != v.end();i++) {
		cout << "姓名：" << (*i)->name << "\t年龄：" << (*i)->age << endl;
	}
}

vector互换容器

实现两个容器内元素进行互换
swap（vec）；将vec与本身的元素互换

void test1() {
	//基本使用
	vector<int> vi;
	for (int i = 0;i <5;i++) {
		vi.push_back(i * 10);
	}
	p(vi);
	vector<int> v2;
	for (int i = 5;i > 0;i--) {
		v2.push_back(i);
	}
	p(v2);
	vi.swap(v2);
	p(vi);
	p(v2);
}

void test1() {
	//实际使用，可以收缩空间
	vector<int> vi;
	for (int i = 0;i <1000;i++) {
		vi.push_back(i * 10);
	}
	cout << "vi第一次容量：" << vi.capacity() << endl;
	cout << "vi第一次大小：" << vi.size() << endl;
	vi.resize(5);
	cout << "vi第2次容量：" << vi.capacity() << endl;
	cout << "vi第2次大小：" << vi.size() << endl;
	//巧用swap收缩内存
	//vector<int>(vi)是匿名函数，用完一次系统会删除
	vector<int>(vi).swap(vi);
	cout << "vi第3次容量：" << vi.capacity() << endl;
	cout << "vi第3次大小：" << vi.size() << endl;
}

vector预留空间

减少vector在动态扩展容量时的扩展次数
reserve（int len）；容器预留len个元素长度，预留位置不初始化，元素不可访问

void test1() {
	//实际使用，可以收缩空间
	vector<int> vi;
	vi.reserve(1000);
	int n = 0;//开辟次数
	int* p = NULL;
	for (int i = 0;i <1000;i++) {
		vi.push_back(i );
		if (p != &vi[0]) {
			p = &vi[0];
			n++;
		}
	}
	cout << n << endl;//1
}

vector容器嵌套容器

理清逻辑

void test1() {
	vector<vector<int>> v;
	//小容器
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	vector<int> v4;
	vector<int> v5;
	//小容器放数据
	for (int i = 0;i < 5;i++) {
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
		v5.push_back(i + 5);
	}
	//大容器放数据
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	v.push_back(v5);
	for (vector<vector<int>>::iterator i = v.begin();i != v.end();i++) {
		for (vector<int>::iterator it = (*i).begin();it != (*i).end();it++) {
			cout<<*it<<" ";
		}
		cout << endl;
	}
}