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区别
- []访问越界 直接挂
- at 抛出 异常 out_of_range
- substr 配合 find查找 邮件用户名
- char * string 互转
- char * 隐式转换 string 反之不可以
- 转大写 toupper
- find 如果找不到 返回 -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 赋值、构造、大小、交换、插入 、删除
- 头部删除 头部插入
- pop_front
- push_front
- 3中迭代器 iterator 普通 reverse_iterator 逆序迭代器 const_iterator只读迭代器
- 排序 sort 引用头文件 algorithm
- 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
}