本文共 14918 字，大约阅读时间需要 49 分钟。

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
   
    #include 
    
     using namespace std;//容器 vector#include 
     
      //使用系统算法的头文件#include 
      
       // 迭代器 遍历功能  用指针理解//普通指针也算一种迭代器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
       
         v; //声明一个容器  这个容器中存放int类型数据 对象名称v	//向容器中加入数据	v.push_back(10);	v.push_back(20);	v.push_back(30);	v.push_back(40);	//遍历容器中的数据	//利用迭代器	vector
        
         ::iterator itBegin = v.begin(); // itBegin指向的是v容器中的起始位置 vector
         
          ::iterator itEnd = v.end(); //itEnd指向v容器中最后一个位置的下一个地址 while (itBegin != itEnd){ cout << *itBegin << endl; itBegin++; } //第二种遍历方式 for (vector
          
           ::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
           
             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
            
             ::iterator it = v.begin(); it != v.end();it++){ cout << "姓名: " << (*it).m_Name << " 年龄：" << it->m_Age << endl; }}//存放自定义数据类型的指针void test04(){ vector
             
               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
              
               ::iterator it = v.begin(); it != v.end();it++){ cout << "姓名：： " << (*it)->m_Name << " 年龄： " << (*it)->m_Age << endl; }}//容器嵌套容器void test05(){ vector
               
                
                 > v; vector
                 
                  v1; vector
                  
                   v2; vector
                   
                    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
                    
                     
                      >::iterator it = v.begin(); it != v.end();it++){ for (vector
                      
                       ::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
   

 

概要

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

 

String和c风格字符串对比：

1. Char*是一个指针，String是一个类——string封装了char*，管理这个字符串，是一个char*型的容器。
2. String封装了很多实用的成员方法——查找find，拷贝copy，删除delete 替换replace，插入insert
3. 不用考虑内存释放和越界—— 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个字符为字符串strstring& 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个字符cstring& 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

 

概览

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

 

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

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

 

vector构造函数

vector
   
     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
    
      v1(arr, arr + sizeof(arr) / sizeof(int));
    
   

使用实例：

void test02(){	vector 
   
    v;	int arr[] = { 2, 3, 4, 1, 9 };	vector
    
      v1(arr, arr + sizeof(arr) / sizeof(int));	vector
     
      v2(v1.begin(), v1.end());  //23419	vector
      
       v3(10, 100); //10个100	//赋值使用	vector
       
        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); //尾部插入元素elepop_back();//删除最后一个元素erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素erase(const_iterator pos);//删除迭代器指向的元素clear();//删除容器中所有元素

 

 

 

各种奇淫技巧

 

巧用swap收缩空间

void test03(){	vector
   
    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
    
     (v).swap(v);	cout << "v的容量" << v.capacity() << endl;	cout << "v的大小" << v.size() << endl;}
    
   

原理：

利用v来初始化匿名对象

vector
   
    (v)
   

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

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

vector
   
    (v).swap(v);
   

 

 

巧用reserve减少扩容次数

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

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

void test04(){	vector
   
    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
   
    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
   
    v;	for ( int  i = 0; i < 10; i++){		v.push_back(i);	}	//reverse_iterator 逆序迭代器	for (vector
    
     ::reverse_iterator it = v.rbegin(); it != v.rend();it++){		cout << *it << " ";	}	cout << endl;	//vector迭代器是随机访问的迭代器  支持跳跃式访问	vector
     
      ::iterator itBegin = v.begin();	itBegin = itBegin + 3;	//如果上述写法不报错，这个迭代器是随机访问迭代器	list
      
       l;	for (int i = 0; i < 10;i++){		l.push_back(i);	}	list
       
        ::iterator lIt = l.begin();	//lIt = lIt + 1; //不支持随机访问}
       
      
     
    
   

 

 

 

deque

 

大纲：

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

 

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

三种迭代器

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

 

deque构造函数

deque
   
     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
   
    &d){	//iterator 普通迭代器  reverse_iterator 逆序迭代器  const_iterator 只读迭代器	for (deque
    
     ::const_iterator it = d.begin(); it != d.end();it++){		//*it = 100000;		cout << *it << " ";	}	cout << endl;}void test01(){	deque
     
      d; //默认构造函数	d.push_back(10);	d.push_back(40);	d.push_back(30);	d.push_back(20);	printDeque(d);//10 40 30 20	deque
      
       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 << "不为空 大小为：" <
       
        << 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
   
    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
    
     d2;	d2.push_back(50);	d2.push_back(60);	d2.insert(d2.begin(), d.begin(), d.end());//从头插入	printDeque(d2);  //  100 10 30 50 60}