STL基础梳理 2019.1.17（STL六大组件、string、vector、deque）

最新推荐文章于 2022-01-30 13:24:03 发布

王小闹儿

最新推荐文章于 2022-01-30 13:24:03 发布

阅读量240

点赞数 1

本文链接：https://blog.csdn.net/qq_29996285/article/details/86527714

版权

C++基础专栏收录该内容

79 篇文章 5 订阅

订阅专栏

STL六大组件简介

容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。

算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function tempalte.

迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* , operator-> , operator++,operator--等指针相关操作予以重载的class template. 所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。

仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class template

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

空间配置器：负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class tempalte.

各种测试用例

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <string>
using namespace std;

//容器 vector
#include <vector>

//使用系统算法的头文件
#include <algorithm>

// 迭代器 遍历功能  用指针理解
//普通指针也算一种迭代器
void test01(){
	int array[5] = { 1, 3, 5, 6, 8 };
	int * p = array; //指针指向数组首地址  &array[0]
	for (int i = 0; i < 5;i ++){
		//cout << array[i] << endl;
		cout << *(p++) << endl;
	}
}

void myPrint(int v){
	cout << v << endl;
}

void test02(){
	//声明容器
	vector<int> v; //声明一个容器  这个容器中存放int类型数据 对象名称v
	//向容器中加入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	//遍历容器中的数据
	//利用迭代器
	vector<int>::iterator itBegin = v.begin(); // itBegin指向的是v容器中的起始位置
	vector<int>::iterator itEnd = v.end(); //itEnd指向v容器中最后一个位置的下一个地址

	while (itBegin != itEnd){
		cout << *itBegin << endl;
		itBegin++;
	}

	//第二种遍历方式
	for (vector<int>::iterator it = v.begin(); it != v.end();it++){
		cout << *it << endl;
	}

	//第三种方式 利用算法
	for_each(v.begin(), v.end(), myPrint);
}

//操作自定义数据类型
class Person{
public:
	Person(string name, int age){
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};

void test03(){
	vector<Person> v;
	Person p1("大头儿子", 10);
	Person p2("小头爸爸", 32);
	Person p3("隔壁王叔叔", 30);
	Person p4("围裙妈妈", 28);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	//遍历
	for (vector<Person>::iterator it = v.begin(); it != v.end();it++){
		cout << "姓名: " << (*it).m_Name << " 年龄：" << it->m_Age << endl;
	}
}

//存放自定义数据类型的指针
void test04(){
	vector<Person *> v;
	Person p1("大头儿子", 10);
	Person p2("小头爸爸", 32);
	Person p3("隔壁王叔叔", 30);
	Person p4("围裙妈妈", 28);

	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);

	for (vector<Person*>::iterator it = v.begin(); it != v.end();it++){
		cout << "姓名：： " << (*it)->m_Name << " 年龄： " << (*it)->m_Age << endl;
	}

}

//容器嵌套容器
void test05(){
	vector<vector<int>> v;
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;

	for (int i = 0; i < 5;i++){
		v1.push_back(i);
		v2.push_back(i + 10);
		v3.push_back(i + 100);
	}
	//将小容器放入到大容器中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);

	//遍历所有数据
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end();it++){
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end();vit++){
			cout << *vit << " ";
		}
		cout << endl;	 
	}
}

int main(){
	//test01();
	//test02();
	//test03();
	//test04();
	test05();
	system("pause");
	return EXIT_SUCCESS;
}

string

头文件

#include<string>

概要

构造、赋值 assign
对字符存取 [] at区别
1. []访问越界直接挂
2. at 抛出异常 out_of_range
substr 配合 find查找邮件用户名
char * string 互转
1. char * 隐式转换 string 反之不可以
转大写 toupper
find 如果找不到返回 -1
1. 找到返回第一次出现的位置

String和c风格字符串对比：

Char*是一个指针，String是一个类——string封装了char*，管理这个字符串，是一个char*型的容器。
String封装了很多实用的成员方法——查找find，拷贝copy，删除delete 替换replace，插入insert
不用考虑内存释放和越界—— string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等。

string 构造函数

string();//创建一个空的字符串 例如: string str;      
string(const string& str);//使用一个string对象初始化另一个string对象
string(const char* s);//使用字符串s初始化
string(int n, char c);//使用n个字符c初始化

上述构造函数的调用方式

string str; //默认构造
string str2(str); //拷贝构造
string str3 = str;//拷贝构造和拷贝赋值
string str4 = "abcd";
string str5(10, 'a');

string基本赋值操作

string& operator=(const char* s);//char*类型字符串 赋值给当前的字符串
string& operator=(const string &s);//把字符串s赋给当前的字符串
string& operator=(char c);//字符赋值给当前的字符串
string& assign(const char *s);//把字符串s赋给当前的字符串
string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s);//把字符串s赋给当前字符串
string& assign(int n, char c);//用n个字符c赋给当前字符串
string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串

操作实例

//基本赋值
str = "hello";
str2 = str4;

//string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串
str3.assign("abcdef", 4);
cout << str3 << endl;


//string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
string str6;
str6.assign(str, 1, 3); //ell 从零开始索引

string存取字符操作

char& operator[](int n);//通过[]方式取字符
char& at(int n);//通过at方法获取字符

使用示例：

void test02(){
	string s = "hello world";

	for (int i = 0; i < s.size();i++){
		//cout << s[i] << endl;
		cout << s.at(i) << endl;
	}
	//[] 和at的区别？[]访问越界  直接挂掉 at会抛出异常

	try{
		//cout << s[100] << endl;
		cout << s.at(100) << endl;
	}
	catch (out_of_range & e){
		cout << e.what() << endl;
	}
	catch (...){
		cout << "越界异常" << endl;
	}
}

string拼接操作

string& operator+=(const string& str);//重载+=操作符
string& operator+=(const char* str);//重载+=操作符
string& operator+=(const char c);//重载+=操作符
string& append(const char *s);//把字符串s连接到当前字符串结尾
string& append(const char *s, int n);//把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s);//同operator+=()
string& append(const string &s, int pos, int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾
string& append(int n, char c);//在当前字符串结尾添加n个字符c

使用例子

void test03(){
	//拼接
	string s1 = "我";
	string s2 = "爱北京";
	s1 += s2;
	cout << s1 << endl; //我爱北京
	s1.append("天安门"); //我爱北京天安门

}

string查找和替换

int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int find(const char* s, int pos = 0) const;  //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const;  //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = 0) const;  //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const;//查找str最后一次位置,从pos开始查找
int rfind(const char* s, int pos = npos) const;//查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const;//从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s

使用样例

void test03(){
	
	//find查找
	string s = "abcdefg";
	int pos = s.find("bcf"); //找不到返回是 -1
	cout << "pos = " << pos << endl;
	
	int pos2 = s.rfind("bc"); //rfind  和find 结果一样，内部查找顺序相反
	cout << "pos2 = " << pos2 << endl; // 4 2   先找到c，后找到b

	//替换
	string s3 = "hello"; //替换从pos开始n个字符为字符串str
	s3.replace(1, 3, "1111");
	cout << s3 << endl; // h11l1o  从e开始的3个字符"ell"被替换成字符串"llll"

}

string比较操作

/*
compare函数在 > 时返回 1，< 时返回 -1，== 时返回 0。
比较区分大小写，比较时参考字典顺序，排越前面的越小。
大写的A比小写的a小。
*/
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较

使用例子

void test04(){
	string s1 = "abc";
	string s2 = "abcd";

	if (s1.compare(s2) == 0){
		cout << "s1 等于 s2" << endl;
	}
	else if (s1.compare(s2) == 1){
		cout << "s1 大于 s2" << endl;
	}
	else{
		cout << "s1 小于 s2" << endl;
	}
}

string子串

string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串

使用例子

void test05(){
	string s1 = "abcde";
	string s2 = s1.substr(1, 3);
	cout << "s2 = " << s2 << endl; //bcd

	//需求  查找一个邮件的 用户名
	string email = "zhangtao@sina.com";
	int pos = email.find("@");//8 
	cout << "pos " << pos << endl;

	string usrName = email.substr(0, pos);
	cout << "用户名为：" << usrName << endl;
}

string插入和删除操作

string& insert(int pos, const char* s); //插入字符串
string& insert(int pos, const string& str); //插入字符串
string& insert(int pos, int n, char c);//在指定位置插入n个字符c
string& erase(int pos, int n = npos);//删除从Pos开始的n个字符

使用例子

void test06(){
	string s1 = "hello";
	s1.insert(1, "111");
	cout << s1 << endl; //h111ello

	//删除 111
	s1.erase(1, 3);
	cout << s1 << endl;
}

string和c-style字符串转换

//string 转 char*
string str = "itcast";
const char* cstr = str.c_str();
//char* 转 string 
char* s = "itcast";
string str(s);

使用例子：

void func(string s){
	cout << s << endl;
}

void func2(const char * s){
	cout << s << endl;
}

void test07(){
	string s = "abc";

	//string -> const char *
	const char * p = s.c_str();

	func(p); //const char * 隐式类型转换为 string

	//const char * -> string 
	string s2(p);
	
	//func2(s2); //string 不能隐式类型转换为 char * 
}

在c++中存在一个从const char*到string的隐式类型转换，却不存在从一个string对象到C_string的自动类型转换。

对于string类型的字符串，可以通过c_str()函数返回string对象对应的C_string.

通常，程序员在整个程序中应坚持使用string类对象，直到必须将内容转化为char*时才将其转换为C_string.

string和const char之间转化会产生的问题

为了修改string字符串的内容，下标操作符[]和at都会返回字符的引用。但当字符串的内存被重新分配之后，可能发生错误.

void test08(){
	string s = "abcdefg";
	char& a = s[2];
	char& b = s[3];

	a = '1';
	b = '2';

	cout << s << endl; //ab12efg
	cout << (int*)s.c_str() << endl;

	s = "pppppppppppppp";

	//地址发生了改变，因此下面两句会出错
	//a = '1';
	//b = '2';

	cout << s << endl;
	cout << (int*)s.c_str() << endl;
}

练习——字符串大小写转化

写一个函数，函数内部将string字符串中的所有小写字母都变为大写字母。

void test09(){
	string s = "abCdEfg";
	for (int i = 0; i < s.size();i++){
		//全变大写
		s[i] = toupper(s[i]);

		//全变小写
		s[i] = tolower(s[i]);
	}
	cout << s << endl;
}

vector

概览

构造、赋值、
大小 size 重置大小 resize 容量 capacity
是否为空 empty 交换 swap
巧用swap收缩空间
reserve 预留空间
insert 插入（迭代器） erase删除（迭代器） clear（）清空容器
pop_back 尾删 front 第一个数据 back最后一个数据
逆序遍历 reverse_iterator rbegin rend
如果区分迭代器是否支持随机访问

注意，测试vector的内存扩展并不是两倍

void test01(){
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
		cout << v.capacity() << endl;  // v.capacity()容器的容量
	}
}

vector构造函数

vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem);//构造函数将n个elem拷贝给本身。
vector(const vector &vec);//拷贝构造函数。

//例子 使用第二个构造函数 我们可以...
int arr[] = {2,3,4,1,9};
vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));

使用实例：

void test02(){
	vector <int >v;
	int arr[] = { 2, 3, 4, 1, 9 };
	vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
	vector<int>v2(v1.begin(), v1.end());  //23419
	vector<int>v3(10, 100); //10个100

	//赋值使用
	vector<int>v4;
	v4.assign(v3.begin(), v3.end()); //10个100
	v4.swap(v2);  //23419
	cout << "v4容器的大小" << v4.size() << endl; //5

	if (v4.empty()){
		cout << "v4空" << endl;
	}else{
		cout << "v4不空" << endl;
	}
	
	//重新制定容器的长度  
	v4.resize(10);    // v4 23419   输出2341900000
	v4.resize(10,-1); //第二个参数是默认值 ，默认0 
	v4.resize(3);  //输出 234
}

vector常用赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
vector& operator=(const vector  &vec);//重载等号操作符
swap(vec);// 将vec与本身的元素互换。

vector大小操作

size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。
capacity();//容器的容量
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。

vector数据存取操作

at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
operator[];//返回索引idx所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素

vector插入和删除操作

insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素

各种奇淫技巧

巧用swap收缩空间

void test03(){
	vector<int>v;
	for (int i = 0; i < 100000; i++){
		v.push_back(i);
	}

	cout << "v的容量" << v.capacity() << endl;
	cout << "v的大小" << v.size() << endl;

	v.resize(3);

	cout << "v的容量" << v.capacity() << endl;
	cout << "v的大小" << v.size() << endl;

	//巧用swap
	vector<int>(v).swap(v);

	cout << "v的容量" << v.capacity() << endl;
	cout << "v的大小" << v.size() << endl;
}

原理：

利用v来初始化匿名对象

vector<int>(v)

此时v中有多少个元素，则匿名对象就会被初始化多大。而v并没有发生任何的改变。但是后面调用了swap函数，交换了匿名对象和v的指针，因此v的容量被改变了。

匿名对象指向的空间在执行完下面代码之后就自动销毁了，因此不用担心内存泄漏。

vector<int>(v).swap(v);

巧用reserve减少扩容次数

reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。

如果不预留空间，则下面代码会进行30次扩容

void test04(){
	vector<int>v;

	int * p = NULL;
	int num = 0;
	for (int i = 0; i < 100000;i++){
		v.push_back(i);
		//每次开辟新的内存空间就会执行下面的函数
		if (p!=&v[0]){
			p = &v[0];
			num++;
		}
	}
	cout << num << endl;
	// 计算开辟100000数据用了多少次
}

改成如下情况，只要申请一次空间即可

void test04(){
	vector<int>v;
	v.reserve(100000); //预留出空间

	int * p = NULL;
	int num = 0;
	for (int i = 0; i < 100000;i++){
		v.push_back(i);
		//每次开辟新的内存空间就会执行下面的函数
		if (p!=&v[0]){
			p = &v[0];
			num++;
		}
	}
	cout << num << endl;
	// 计算开辟100000数据用了多少次
}

反向遍历迭代器——reverse_iterator

void test06(){
	//逆序遍历
	vector<int>v;
	for ( int  i = 0; i < 10; i++){
		v.push_back(i);
	}

	//reverse_iterator 逆序迭代器
	for (vector<int>::reverse_iterator it = v.rbegin(); it != v.rend();it++){
		cout << *it << " ";
	}
	cout << endl;

	//vector迭代器是随机访问的迭代器  支持跳跃式访问
	vector<int>::iterator itBegin = v.begin();
	itBegin = itBegin + 3;
	//如果上述写法不报错，这个迭代器是随机访问迭代器


	list<int>l;
	for (int i = 0; i < 10;i++){
		l.push_back(i);
	}
	list<int>::iterator lIt = l.begin();
	//lIt = lIt + 1; //不支持随机访问
}

deque

大纲：

双端数组没有容量
API 赋值、构造、大小、交换、插入、删除
头部删除头部插入
1. pop_front
2. push_front
3中迭代器 iterator 普通 reverse_iterator 逆序迭代器 const_iterator只读迭代器
排序 sort 引用头文件 algorithm
1. sort(d.begin(),d.end()) 从小到大

Deque采取一块所谓的map(注意，不是STL的map容器。博主注：不使用vector做的吗？？？)作为主控，这里所谓的map是一小块连续的内存空间，其中每一个元素(此处成为一个结点)都是一个指针，指向另一段连续性内存空间，称作缓冲区。缓冲区才是deque的存储空间的主体。

三种迭代器

iterator 普通迭代器
reverse_iterator 逆序迭代器
const_iterator 只读迭代器

deque构造函数

deque<T> deqT;//默认构造形式
deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem);//构造函数将n个elem拷贝给本身。
deque(const deque &deq);//拷贝构造函数。

deque赋值操作

assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符 
swap(deq);// 将deq与本身的元素互换

deque大小操作

deque.size();//返回容器中元素的个数
deque.empty();//判断容器是否为空
deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。

使用实例：

void printDeque(const deque<int>&d){
	//iterator 普通迭代器  reverse_iterator 逆序迭代器  const_iterator 只读迭代器
	for (deque<int>::const_iterator it = d.begin(); it != d.end();it++){
		//*it = 100000;
		cout << *it << " ";
	}
	cout << endl;
}

void test01(){
	deque<int>d; //默认构造函数

	d.push_back(10);
	d.push_back(40);
	d.push_back(30);
	d.push_back(20);

	printDeque(d);//10 40 30 20

	deque<int>d2(d.begin(), d.end());
	d2.push_back(10000);

	//交换
	d.swap(d2);

	printDeque(d); //10 40 30 20 10000

	// d2  10 40 30 20
	if (d2.empty()){
		cout << "为空" << endl;
	}else{
		cout << "不为空 大小为：" <<d2.size() << endl;
	}
}

deque双端插入和删除操作

push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据

deque数据存取

at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
front();//返回第一个数据。
back();//返回最后一个数据

deque插入操作

insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。

deque删除操作

clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。

使用实例：

void test02(){
	deque<int>d;
	d.push_back(10);
	d.push_back(30);
	d.push_back(20);
	d.push_front(100);
	d.push_front(200);

	printDeque(d); // 200 100 10 30 20

	//删除 头删 尾删
	d.pop_back();
	d.pop_front();
	printDeque(d); // 100 10 30

	cout << "front: " << d.front() << endl;
	cout << "back: " << d.back() << endl;

	//插入
	deque<int>d2;
	d2.push_back(50);
	d2.push_back(60);
	d2.insert(d2.begin(), d.begin(), d.end());//从头插入
	printDeque(d2);  //  100 10 30 50 60

}

王小闹儿

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
STL基础梳理 2019.1.17（STL六大组件、string、vector、deque）

STL六大组件简介容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function tempalte.迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是...
复制链接

扫一扫