STL"/>
C++ —— STL
基本概念
STL(Standard Template Library,标准模板库)是惠普实验室开发的一系列软件的统称,现然主要出现在C++中,但在被引入C++之前该技术就已经存在了很长的一段时间了.
STL从广义上讲分为三类:algorithm(算法)、container(容器)、iterator(迭代器),容器和算法通过迭代器可以进行无缝连接,几乎所有的代码都采用模板类和模板函数的方式,这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。
使用STL的好处:
1) STL是C++的一部分,因此不用额外安装什么,它就内建在编译器内。
2) STL的一个重要特点是数据结构和算法分离。尽管这是个简单的概念,但是这和分离确实使得STL变得非常通用。
例如:在STL的vector容器中,可以放入元素、基础数据类型变量、元素地址;STL的sort()函数可以用来操作vector、list等容器.
3) 程序员可以不用思考STL具体实现过程,只要能够熟练使用STL就OK了,这样他们就可以把精力放在程序开发的或别的方面了。
4) STL具有高可重用性、高性能、高移植性、跨平台的优点。
5) 了解到STL的这些好处,我们知道STL无疑是最值得C++程序员骄傲的一部分,每一个C++程序员都应好好学习STL。
STL的基本见习:
container(容器)和iterator(迭代器)
string容器
1). string容器概念(#include )
string是STL的字符串类型,通常用来表示字符串。而在使用string之前,字符串通常是用char表示的.string与char都可以用来表示字符串.
string是一个类, char是一个指向字符的指针.string封装了char,管理这个字符串,是一个char*型的容器。
string不用考虑内存释放和越界。string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等。
string提供了一系列的字符串操作函数,查找find、拷贝copy、删除erase、替换replace、插入insert等.
2). string的构造函数
默认构造函数： string(); //构造一个空的字符串string s1。
拷贝构造函数： string(const string &str); //构造一个与str一样的string。如string s1(s2)。
带参数的构造函数： string(const char *s); //用字符串s初始化
string(int n,char c); //用n个字符c初始化
3).string类的字符操作
const char &operator[] (int n) const;
const char &at(int n) const;
char &operator[] (int n);
char &at(int n);
operator[]和at()均返回当前字符串中第n个字符,但二者是有区别的。主要区别在于at()在越界时会抛出异常，[]在刚好越界时会返回(char)0，再继续越界时，编译器直接出错。如果你的程序希望可以通过try,catch捕获异常，建议采用at()。
4).从string取得const char*的操作
const char *c_str() const; //返回一个以’\0’结尾的字符串的首地址
5).把string拷贝到char*指向的内存空间的操作
int copy(char *s, int n, int pos=0) const;
//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中,返回实际拷贝的数目。注意要保证s所指向的空间足够大以容纳当前字符串,不然会越界。
6). string的长度
int length() const; //返回当前字符串的长度。长度不包括字符串结尾的’\0’。
bool empty() const; //当前字符串是否为空
7). string的赋值
string &operator=(const string &s); //把字符串s赋给当前的字符串
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个字符赋给当前字符串
8). string字符串连接
string &operator+=(const string &s); //把字符串s连接到当前字符串结尾
string &operator+=(const char *s); //把字符串s连接到当前字符串结尾
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
9). string的比较
int compare(const string &s) const; //与字符串s比较
int compare(const char *s) const; //与字符串s比较
//compare函数在>时返回 1，<时返回 -1，==时返回 0。比较区分大小写，比较时参考字典顺序，排越前面的越小。大写的A比小写的a小。
10). string的子串
string substr(int pos=0, int n=npos) const; //返回由pos开始的n个字符组成的子字符串
11). string的查找和替换
查找
int find(char c,int pos=0) const; //从pos开始查找字符c在当前字符串的位置
int find(const char *s, int pos=0) const; //从pos开始查找字符串s在当前字符串的位置
int find(const string &s, int pos=0) const; //从pos开始查找字符串s在当前字符串中的位置
//find函数如果查找不到，就返回-1
int rfind(char c, int pos=npos) const; //从pos开始从后向前查找字符c在当前字符串中的位置,npos为最后的位置,常用于循环条件结束判断
int rfind(const char *s, int pos=npos) const;
int rfind(const string &s, int pos=npos) const;
//rfind是反向查找的意思，如果查找不到， 返回-1
替换
string &replace(int pos, int n, const char *s); //删除从pos开始的n个字符，然后在pos处插入串s
string &replace(int pos, int n, const string &s); //删除从pos开始的n个字符，然后在pos处插入串s
void swap(string &s2); //交换当前字符串与s2的值
12). String的区间删除和插入
string &insert(int pos, const char *s);
string &insert(int pos, const string &s);
//前两个函数在pos位置插入字符串s
string &insert(int pos, int n, char c); //在pos位置 插入n个字符c
string &erase(int pos=0, int n=npos); //删除pos开始的n个字符，返回修改后的字符串
13). string算法相关
void fun()
{string s2 = "AAAbbb";transform(s2.begin(), s2.end(), s2.begin(), toupper); //转换大写cout << s2 << endl;string s3 = "AAAbbb";transform(s3.begin(), s3.end(), s3.begin(), tolower); //转换小写cout << s3 << endl;
}
vector容器
1). vector容器简介(#include <vector>)
vector是将元素置于一个动态数组中加以管理的容器.
vector可以随机存取元素(支持索引值直接存取,用[]操作符或at()方法).
vector尾部添加或移除元素非常快速;但是在中部或头部插入元素或移除元素比较费时.2). vector对象的默认构造
vector采用模板类实现,vector对象的默认构造形式
vector<T> vect;
vector<int> vecInt; //一个存放int的vector容器。
vector<float> vecFloat; //一个存放float的vector容器。
vector<string> vecString; //一个存放string的vector容器。
... //尖括号内还可以设置指针类型或自定义类型。
class CA{};
vector<CA*> vecpCA; //用于存放CA对象的指针的vector容器。
vector<CA> vecCA; //用于存放CA对象的vector容器。由于容器元素的存放是按值复制的方式进行的，所以此时CA必须提供CA的拷贝构造函数,以保证CA对象间拷贝正常.3). vector对象的带参数构造
vector(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。注意该区间是左闭右开的区间。
vector(n,elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数int iArray[] = {0,1,2,3,4};
vector<int> vecIntA( iArray, iArray+5 );vector<int> vecIntB ( vecIntA.begin() , vecIntA.end() ); //用构造函数初始化容器vecIntB
vector<int> vecIntB ( vecIntA.begin() , vecIntA.begin()+3 );
vector<int> vecIntC(3,9); //此代码运行后，容器vecIntB就存放3个元素，每个元素的值是9。vector<int> vecIntD(vecIntA);4). vector的大小
vector.size(); //返回容器中元素的个数
vector.empty(); //判断容器是否为空
vector.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
vector.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。例如:vecInt是vector<int>声明的容器，现已包含1,2,3元素。
int iSize = vecInt.size(); //iSize == 3;
bool bEmpty = vecInt.empty(); // bEmpty == false;
执行vecInt.resize(5); //此时里面包含1,2,3,0,0元素。
再执行vecInt.resize(8,3); //此时里面包含1,2,3,0,0,3,3,3元素。
再执行vecInt.resize(2); //此时里面包含1,2元素。5). vector末尾的添加移除操作
vector<int> vecInt;
vecInt.push_back(1); //在容器尾部加入一个元素
vecInt.push_back(3);
vecInt.push_back(5);
vecInt.push_back(7);
vecInt.push_back(9);
vecInt.pop_back(); //移除容器中最后一个元素
//{1,3,5 ,7} 6). vector的数据存取
vec.at(idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
vec[idx]; //返回索引idx所指的数据，越界时，运行直接报错vector<int> vecInt; //假设包含1 ,3 ,5 ,7 ,9
vecInt.at(2) == vecInt[2] ; //5
vecInt.at(2) = 8;或vecInt[2] = 8;
vecInt就包含1, 3, 8, 7, 9值int iF = vector.front(); //iF==1
int iB = vector.back(); //iB==9
vector.front() = 11; //vecInt包含{11,3,8,7,9}
vector.back() = 19; //vecInt包含{11,3,8,7,19}其它函数:assign();7). 迭代器基本原理
*迭代器是一个"可遍历STL容器内全部或部分元素”的对象。
*迭代器指出容器中的一个特定位置。
*迭代器就如同一个指针。
*迭代器提供对一个容器中的对象的访问方法，并且可以定义了容器中对象的范围。
*这里大概介绍一下迭代器的类别。
*输入迭代器:也有叫法称之为”只读迭代器”,它从容器中读取元素,只能一次读入一个元素向前移动,只支持一遍算法,同一个输入迭代器不能两遍遍历一个序列。
*输出迭代器:也有叫法称之为”只写迭代器”,它往容器中写入元素,只能一次写入一个元素向前移动,只支持一遍算法,同一个输出迭代器不能两遍遍历一个序列。
*正向迭代器:组合输入迭代器和输出迭代器的功能,还可以多次解析一个迭代器指定的位置,可以对一个值进行多次读/写。
*双向迭代器:组合正向迭代器的功能,还可以通过--操作符向后移动位置。
*随机访问迭代器：组合双向迭代器的功能，还可以向前向后跳过任意个位置，可以直接访问容器中任何位置的元素。
目前本系列教程所用到的容器,都支持双向迭代器或随机访问迭代器,下面将会详细介绍这两个类别的迭代器。8). 双向迭代器与随机访问迭代器
双向迭代器支持的操作：
it++, ++it, it--, --it，*it， itA = itB，itA == itB，itA != itB其中list,set,multiset,map,multimap支持双向迭代器。
随机访问迭代器支持的操作：
在双向迭代器的操作基础上添加
it+=i,it-=i,it+i(或it=it+i),it[i],itA<itB,itA<=itB,itA>itB,itA>=itB 的功能。其中vector，deque支持随机访问迭代器。9). vector与迭代器的配合使用
vector<int> vecInt; //假设包含1,3,5,7,9元素
vector<int>::iterator it; //声明容器vector<int>的迭代器。
it = vecInt.begin(); // *it == 1
++it; //或者it++; *it == 3 ，前++的效率比后++的效率高，前++返回引用，后++返回值。
it += 2; //*it == 7
it = it+1; //*it == 9
++it; // it == vecInt.end(); 此时不能再执行*it,会出错!正向遍历：
for(vector<int>::iterator it=vecInt.begin(); it!=vecInt.end(); ++it)
{int iItem = *it; cout << iItem; //或直接使用 cout << *it;
}
这样子便打印出1 3 5 7 9逆向遍历：
for(vector<int>::reverse_iterator rit=vecInt.rbegin(); rit!=vecInt.rend(); ++rit) //注意，小括号内仍是++rit
{int iItem = *rit;cout << iItem; //或直接使用cout << *rit;
}
此时将打印出9,7,5,3,1
注意，这里迭代器的声明采用vector<int>::reverse_iterator，而非vector<int>::iterator。迭代器还有其它两种声明方法：
vector<int>::const_iterator 与 vector<int>::const_reverse_iterator 以上两种分别是vector<int>::iterator 与vector<int>::reverse_iterator 的只读形式，使用这两种迭代器时，不会修改到容器中的值。
备注：不过容器中的insert和erase方法仅接受这四种类型中的iterator，其它三种不支持。《Effective STL》建议我们尽量使用iterator取代const_iterator、reverse_iterator和const_reverse_iterator:for(vector<int>::iterator it=vector.end();it!=vector.begin();){cout<<*(--it)<<" ";}10). vector的插入
vector.insert(pos,elem); //在pos(迭代器)位置插入一个elem元素的拷贝，返回新数据的位置。
vector.insert(pos,n,elem); //在pos(迭代器)位置插入n个elem数据，无返回值。
vector.insert(pos,beg,end); //在pos(迭代器)位置插入[beg,end)区间的数据，无返回值
简单案例:
vector<int> vecA;vector<int> vecB;vecA.push_back(1);vecA.push_back(3);vecA.push_back(5);vecA.push_back(7);vecA.push_back(9);vecB.push_back(2);vecB.push_back(4);vecB.push_back(6);vecB.push_back(8);vecA.insert(vecA.begin(), 11); //{11, 1, 3, 5, 7, 9} 如:vecA.insert(A.begin()+=2,9527); {11, 1, 9527,3, 5, 7, 9} vecA.insert(vecA.begin()+1,2,33); //{11,33,33,1,3,5,7,9}vecA.insert(vecA.begin() , vecB.begin() , vecB.end() ); //{2,4,6,8,11,33,33,1,3,5,7,9} 如: A.insert(A.end(),B.rbegin(),B.rend());11). vector的删除
理论知识:
vector.clear(); //移除容器的所有数据
vec.erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
vec.erase(pos); //删除pos位置的数据，返回下一个数据的位置。
简单案例:
删除区间内的元素
vecInt是用vector<int>声明的容器，现已包含按顺序的1,3,5,6,9元素。
vector<int>::iterator itBegin=vecInt.begin()+1;
vector<int>::iterator itEnd=vecInt.begin()+2;
vecInt.erase(itBegin,itEnd);
//此时容器vecInt包含按顺序的1,6,9三个元素。假设 vecInt 包含1,3,2,3,3,3,4,3,5,3，删除容器中等于3的元素
for(vector<int>::iterator it=vecInt.being(); it!=vecInt.end(); ) //小括号里不需写 ++it
{if(*it == 3){it = vecInt.erase(it); //以迭代器为参数，删除元素3，并把数据删除后的下一个元素位置返回给迭代器。//此时，不执行 ++it； }else{++it;}
}//删除vecInt的所有元素
vecInt.clear(); //容器为空
Deque容器
1).Deque简介(#include <deque>)
*deque是”double-ended queue”的缩写,和vector一样都是STL的容器,deque是双端数组,而vector是单端的.
*deque在接口上和vector非常相似,在许多操作的地方可以直接替换。
*deque可以随机存取元素（支持索引值直接存取,用[]操作符或at()方法）。
*deque头部和尾部添加或移除元素都非常快速。但是在中部安插元素或移除元素比较费时。2). deque对象的默认构造
deque采用模板类实现,deque对象的默认构造形式:deque<T> deqT;
deque <int> deqInt; //一个存放int的deque容器。
deque <float> deqFloat; //一个存放float的deque容器。
deque <string> deqString; //一个存放string的deque容器。
... //尖括号内还可以设置指针类型或自定义类型。
int arr[]={1,3,5,7,9};
deque<int> dequeInt(arr,arr+5);3). deque末尾的添加移除操作
理论知识:
deque.push_back(elem); //在容器尾部添加一个数据
deque.push_front(elem); //在容器头部插入一个数据
deque.pop_back(); //删除容器最后一个数据
deque.pop_front(); //删除容器第一个数据deque<int> deqInt;
deqInt.push_back(1);
deqInt.push_back(3);
deqInt.push_back(5);
deqInt.push_back(7);
deqInt.push_back(9);
deqInt.pop_front();
deqInt.pop_front();
deqInt.push_front(11);
deqInt.push_front(13);
deqInt.pop_back();
deqInt.pop_back();
//deqInt { 13,11,5}4). deque的数据存取
理论知识:
deque.at(idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range。
deque[idx]; //返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
deque.front(); //返回第一个数据。
deque.back(); //返回最后一个数据deque<int> deqInt;deqInt.push_back(1);deqInt.push_back(3);deqInt.push_back(5);deqInt.push_back(7);deqInt.push_back(9);int iA = deqInt.at(0); //1int iB = deqInt[1]; //3deqInt.at(0) = 99; //99deqInt[1] = 88; //88int iFront = deqInt.front(); //99int iBack = deqInt.back(); //9deqInt.front() = 77; //77deqInt.back() = 66; //665). deque对象的带参数构造
理论知识:
deque(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。注意该区间是左闭右开的区间。
deque(n,elem); //构造函数将n个elem拷贝给本身。
deque(const deque &deq); //拷贝构造函数。deque<int> deqIntA;deqIntA.push_back(1);deqIntA.push_back(3);deqIntA.push_back(5);deqIntA.push_back(7);deqIntA.push_back(9);deque<int> deqIntB(deqIntA.begin(),deqIntA.end()); //1 3 5 7 9deque<int> deqIntC(5,8); //8 8 8 8 8deque<int> deqIntD(deqIntA); //1 3 5 7 96). deque的赋值
理论知识:
deque.assign(beg,end); //将[beg, end)区间中的数据拷贝赋值给本身。注意该区间是左闭右开的区间。
deque.assign(n,elem); //将n个elem拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符
deque.swap(deq); // 将vec与本身的元素互换deque<int> deqIntA,deqIntB,deqIntC,deqIntD;deqIntA.push_back(1);deqIntA.push_back(3);deqIntA.push_back(5);deqIntA.push_back(7);deqIntA.push_back(9);deqIntB.assign(deqIntA.begin(),deqIntA.end()); // 1 3 5 7 9 deqIntC.assign(5,8); //8 8 8 8 8deqIntD = deqIntA; //1 3 5 7 9deqIntC.swap(deqIntD); //互换7). deque的大小
理论知识:
deque.size(); //返回容器中元素的个数
deque.empty(); //判断容器是否为空
deque.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。deque<int> deqIntA;deqIntA.push_back(1);deqIntA.push_back(3);deqIntA.push_back(5);int iSize = deqIntA.size(); //3if (!deqIntA.empty()){deqIntA.resize(5); //1 3 5 0 0deqIntA.resize(7,1); //1 3 5 0 0 1 1deqIntA.resize(2); //1 3}8). deque的插入
理论知识:
deque.insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
deque.insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值。
deque.insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值。deque<int> deqA;deque<int> deqB;deqA.push_back(1);deqA.push_back(3);deqA.push_back(5);deqA.push_back(7);deqA.push_back(9);deqB.push_back(2);deqB.push_back(4);deqB.push_back(6);deqB.push_back(8); deqA.insert(deqA.begin(), 11); //{11, 1, 3, 5, 7, 9}deqA.insert(deqA.begin()+1,2,33); //{11,33,33,1,3,5,7,9}deqA.insert(deqA.begin() , deqB.begin() , deqB.end() ); //{2,4,6,8,11,33,33,1,3,5,7,9}9). deque的删除
理论知识:
deque.clear(); //移除容器的所有数据
deque.erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
deque.erase(pos); //删除pos位置的数据，返回下一个数据的位置。删除区间内的元素
deqInt是用deque<int>声明的容器，现已包含按顺序的1,3,5,6,9元素。
deque<int>::iterator itBegin=deqInt.begin()+1;
deque<int>::iterator itEnd=deqInt.begin()+3;
deqInt.erase(itBegin,itEnd);
//此时容器deqInt包含按顺序的1,6,9三个元素。假设 deqInt 包含1,3,2,3,3,3,4,3,5,3，删除容器中等于3的元素
for(deque<int>::iterator it=deqInt.being(); it!=deqInt.end(); ) //小括号里不需写 ++it
{if(*it == 3){it = deqInt.erase(it); //以迭代器为参数，删除元素3，并把数据删除后的下一个元素位置返回给迭代器。//此时，不执行 ++it； }else{++it;}
}//删除deqInt的所有元素
deqInt.clear(); //容器为空
stack容器
1).Stack简介(#include <stack>)
stack是堆栈容器,是一种“先进后出”的容器。
stack是简单地装饰deque容器而成为另外的一种容器。2). stack对象的默认构造
stack采用模板类实现,stack对象的默认构造形式:stack <T> stkT;
stack <int> stkInt; //一个存放int的stack容器。
stack <float> stkFloat; //一个存放float的stack容器。
stack <string> stkString; //一个存放string的stack容器。
...
//尖括号内还可以设置指针类型或自定义类型。3). stack的push()与pop()方法
stack.push(elem); //往栈头添加元素
stack.pop(); //从栈头移除第一个元素stack<int> stkInt;
stkInt.push(1);stkInt.push(3);stkInt.pop();
stkInt.push(5);stkInt.push(7);
stkInt.push(9);stkInt.pop();
stkInt.pop();
此时stkInt存放的元素是1,54). stack对象的拷贝构造与赋值
stack(const stack &stk); //拷贝构造函数
stack& operator=(const stack &stk); //重载等号操作符stack<int> stkIntA;stkIntA.push(1);stkIntA.push(3);stkIntA.push(5);stkIntA.push(7);stkIntA.push(9);stack<int> stkIntB(stkIntA); //拷贝构造stack<int> stkIntC;stkIntC = stkIntA; //赋值5). stack的数据存取
stack.top(); //返回最后一个压入栈元素stack<int> stkIntA;stkIntA.push(1);stkIntA.push(3);stkIntA.push(5);stkIntA.push(7);stkIntA.push(9);int iTop = stkIntA.top(); //9stkIntA.top() = 19; //196). stack的大小
stack.empty(); //判断堆栈是否为空
stack.size(); //返回堆栈的大小stack<int> stkIntA;stkIntA.push(1);stkIntA.push(3);stkIntA.push(5);stkIntA.push(7);stkIntA.push(9);遍历:while(!stkIntA.empty())
{cout<<stkIntA.top();stkIntA.pop();
}
Queue容器
1).Queue简介(#include <queue>)
queue是队列容器，是一种”先进先出”的容器。
queue是简单地装饰deque容器而成为另外的一种容器。2). queue对象的默认构造
queue采用模板类实现,queue对象的默认构造形式:queue<T> queT; 如：
queue<int> queInt; //一个存放int的queue容器。
queue<float> queFloat; //一个存放float的queue容器。
queue<string> queString; //一个存放string的queue容器。
...
//尖括号内还可以设置指针类型或自定义类型。3). queue的push()与pop()方法
queue.push(elem); //往队尾添加元素
queue.pop(); //从队头移除第一个元素queue<int> queInt;
queInt.push(1);queInt.push(3);
queInt.push(5);queInt.push(7);
queInt.push(9);queInt.pop();
queInt.pop();
此时queInt存放的元素是5,7,9遍历:while(!queInt.empty()){cout<< queInt.front();queInt.pop();}4). queue对象的拷贝构造与赋值
queue(const queue &que); //拷贝构造函数
queue& operator=(const queue &que); //重载等号操作符queue<int> queIntA;queIntA.push(1);queIntA.push(3);queIntA.push(5);queIntA.push(7);queIntA.push(9);queue<int> queIntB(queIntA); //拷贝构造queue<int> queIntC;queIntC = queIntA; //赋值5). queue的数据存取
queue.back(); //返回最后一个元素
queue.front(); //返回第一个元素queue<int> queIntA;queIntA.push(1);queIntA.push(3);queIntA.push(5);queIntA.push(7);queIntA.push(9);int iFront = queIntA.front(); //1int iBack = queIntA.back(); //9queIntA.front() = 11; //11queIntA.back() = 19; //196). queue的大小
queue.empty(); //判断队列是否为空
queue.size(); //返回队列的大小queue<int> queIntA; queIntA.push(1); queIntA.push(3); queIntA.push(5); queIntA.push(7); queIntA.push(9); if (!queIntA.empty()){int iSize = queIntA.size(); //5}
List容器
1). List简介(#include <list>)
list是一个双向链表容器,可高效地进行插入删除元素。
list不可以随机存取元素,所以不支持at.(pos)函数与[]操作符。It++(ok) it+5(err)
2). list对象的默认构造
list采用采用模板类实现,对象的默认构造形式：list<T> lstT; 如：
list<int> lstInt; //定义一个存放int的list容器。
list<float> lstFloat; //定义一个存放float的list容器。
list<string> lstString; //定义一个存放string的list容器。
...
//尖括号内还可以设置指针类型或自定义类型。
2). list头尾的添加移除操作
list.push_back(elem); //在容器尾部加入一个元素
list.pop_back(); //删除容器中最后一个元素
list.push_front(elem); //在容器开头插入一个元素
list.pop_front(); //从容器开头移除第一个元素list<int> lstInt;lstInt.push_back(1);lstInt.push_back(3);lstInt.push_back(5);lstInt.push_back(7);lstInt.push_back(9);lstInt.pop_front();lstInt.pop_front();lstInt.push_front(11);lstInt.push_front(13);lstInt.pop_back();lstInt.pop_back();
// lstInt {13,11,5}3). list的数据存取
list.front(); //返回第一个元素。
list.back(); //返回最后一个元素。
list<int> lstInt;lstInt.push_back(1);lstInt.push_back(3);lstInt.push_back(5);lstInt.push_back(7);lstInt.push_back(9);int iFront = lstInt.front(); //1int iBack = lstInt.back(); //9lstInt.front() = 11; //11lstInt.back() = 19; //194). list与迭代器
list.begin(); //返回容器中第一个元素的迭代器。
list.end(); //返回容器中最后一个元素之后的迭代器。
list.rbegin(); //返回容器中倒数第一个元素的迭代器。
list.rend(); //返回容器中倒数最后一个元素的后面的迭代器。list<int> lstInt;lstInt.push_back(1);lstInt.push_back(3);lstInt.push_back(5);lstInt.push_back(7);lstInt.push_back(9);for (list<int>::iterator it=lstInt.begin(); it!=lstInt.end(); ++it){cout << *it;cout << " ";}for (list<int>::reverse_iterator rit=lstInt.rbegin(); rit!=lstInt.rend(); ++rit){cout << *rit;cout << " ";}5). list对象的带参数构造
list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。注意该区间是左闭右开的区间。
list(n,elem); //构造函数将n个elem拷贝给本身。
list(const list &lst); //拷贝构造函数。list<int> lstIntA;lstIntA.push_back(1);lstIntA.push_back(3);lstIntA.push_back(5);lstIntA.push_back(7);lstIntA.push_back(9);list<int> lstIntB(lstIntA.begin(),lstIntA.end()); //1 3 5 7 9list<int> lstIntC(5,8); //8 8 8 8 8 list<int> lstIntD(lstIntA); //1 3 5 7 96). list的赋值
list.assign(beg,end); //将[beg, end)区间中的数据拷贝赋值给本身。注意该区间是左闭右开的区间。
list.assign(n,elem); //将n个elem拷贝赋值给本身。
list& operator=(const list &lst); //重载等号操作符
list.swap(lst); //将lst与本身的元素互换。list<int> lstIntA,lstIntB,lstIntC,lstIntD;lstIntA.push_back(1);lstIntA.push_back(3);lstIntA.push_back(5);lstIntA.push_back(7);lstIntA.push_back(9);lstIntB.assign(lstIntA.begin(),lstIntA.end()); //1 3 5 7 9lstIntC.assign(5,8); //8 8 8 8 8lstIntD = lstIntA; //1 3 5 7 9lstIntC.swap(lstIntD); //互换7). list的大小
list.size(); //返回容器中元素的个数
list.empty(); //判断容器是否为空
list.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
list.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。list<int> lstIntA;lstIntA.push_back(1);lstIntA.push_back(3);lstIntA.push_back(5);if (!lstIntA.empty()){int iSize = lstIntA.size(); //3lstIntA.resize(5); //1 3 5 0 0lstIntA.resize(7,1); //1 3 5 0 0 1 1lstIntA.resize(2); //1 3}8). list的插入
list.insert(pos,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
list.insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值。
list.insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据，无返回值。list<int> lstA;list<int> lstB;lstA.push_back(1);lstA.push_back(3);lstA.push_back(5);lstA.push_back(7);lstA.push_back(9);lstB.push_back(2);lstB.push_back(4);lstB.push_back(6);lstB.push_back(8);lstA.insert(lstA.begin(), 11); //{11, 1, 3, 5, 7, 9}lstA.insert(++lstA.begin(),2,33); //{11,33,33,1,3,5,7,9}lstA.insert(lstA.begin() , lstB.begin() , lstB.end() ); //{2,4,6,8,11,33,33,1,3,5,7,9}9). list的删除
list.clear(); //移除容器的所有数据
list.erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。
list.erase(pos); //删除pos位置的数据，返回下一个数据的位置。
lst.remove(elem); //删除容器中所有与elem值匹配的元素。删除区间内的元素
lstInt是用list<int>声明的容器,现已包含按顺序的1,3,5,6,9元素。
list<int>::iterator itBegin=lstInt.begin();
++ itBegin;
list<int>::iterator itEnd=lstInt.begin();
++ itEnd;
++ itEnd;
++ itEnd;
lstInt.erase(itBegin,itEnd);
//此时容器lstInt包含按顺序的1,6,9三个元素。假设 lstInt 包含1,3,2,3,3,3,4,3,5,3，删除容器中等于3的元素的方法一
for(list<int>::iterator it=lstInt.being(); it!=lstInt.end(); ) //小括号里不需写 ++it
{if(*it == 3){it = lstInt.erase(it); //以迭代器为参数，删除元素3，并把数据删除后的下一个元素位置返回给迭代器。//此时，不执行 ++it； }else{++it;}
}删除容器中等于3的元素的方法二
lstInt.remove(3);删除lstInt的所有元素
lstInt.clear(); //容器为空10). list的反序排列
lst.reverse(); //反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。list<int> lstA; lstA.push_back(1);lstA.push_back(3);lstA.push_back(5);lstA.push_back(7);lstA.push_back(9);lstA.reverse(); //9 7 5 3 1
Set和multiset容器
1). set/multiset的简介(#include <set>)
*set是一个集合容器,其中所包含的元素是唯一的,集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入,所以不能指定插入位置。
*set采用红黑树变体的数据结构实现,红黑树属于平衡二叉树。在插入操作和删除操作上比vector快。
*set不可以直接存取元素。（不可以使用at.(pos)与[]操作符）。
*multiset与set的区别:set支持唯一键值,每个元素值只能出现一次;而multiset中同一值可以出现多次。
*不可以直接修改set或multiset容器中的元素值,因为该类容器是自动排序的。如果希望修改一个元素值,必须先删除原有的元素,再插入新的元素。2). set/multiset对象的默认构造
set<int> setInt; //一个存放int的set容器。
set<float> setFloat; //一个存放float的set容器。
set<string> setString; //一个存放string的set容器。
multiset<int> mulsetInt; //一个存放int的multi set容器。
multi set<float> multisetFloat; //一个存放float的multi set容器。
multi set<string> multisetString; //一个存放string的multi set容器。3). set的插入与迭代器
set.insert(elem); //在容器中插入元素。
set.begin(); //返回容器中第一个数据的迭代器。
set.end(); //返回容器中最后一个数据之后的迭代器。
set.rbegin(); //返回容器中倒数第一个元素的迭代器。
set.rend(); //返回容器中倒数最后一个元素的后面的迭代器。set<int> setInt;
setInt.insert(3); setInt.insert(1);setInt.insert(5);setInt.insert(2);
for(set<int>::iterator it=setInt.begin(); it!=setInt.end(); ++it)
{int iItem = *it;cout << iItem; //或直接使用cout << *it
}
//这样子便顺序输出 1 2 3 5。set.rbegin()与set.rend()。4). Set集合的元素排序
(1)基础
set<int,less<int> > setIntA; //该容器是按升序方式排列元素。
set<int,greater<int>> setIntB; //该容器是按降序方式排列元素。
set<int> 相当于 set<int,less<int>>。
less<int>与greater<int>中的int可以改成其它类型，该类型主要要跟set容纳的数据类型一致。
疑问1：less<>与greater<>是什么？
疑问2：如果set<>不包含int类型，而是包含自定义类型，set容器如何排序？
要解决如上两个问题，需要了解容器的函数对象，也叫伪函数，英文名叫functor。
下面将讲解什么是functor，functor的用法。
使用stl提供的函数对象
set<int,greater<int>> setIntB;
setIntB.insert(3);
setIntB.insert(1);
setIntB.insert(5);
setIntB.insert(2);
此时容器setIntB就包含了按顺序的5,3,2,1元素int arrset[]={5,3,6,10,2,7,10,8};set<int,less<int>> myset(arrset,arrset+(sizeof(arrset)/sizeof(int)));for(set<int,less<int>>::iterator it=myset.begin();it!=myset.end();it++){cout<<*it<<" ";}string strmultiset[]={"包","顺","佛"," 顺","在","佛","和"};multiset<string,greater<string>> mymultiset(strmultiset,strmultiset+(sizeof(strmultiset)/sizeof(string)));for(multiset<string,greater<string>>::iterator it=mymultiset.begin();it!=mymultiset.end();it++){cout<<*it<<" ";}(2)怎么将结构体存入Set容器struct stuSet
{stuSet(int n=0,float p=3.14){num=n;pi=p;}int num;float pi;char buf[10];//必须重载’<’,否则不能插入结构体。函数必须放在最低下bool operator < (const SS& src)const{return num < src.num;}
};5). 函数对象functor的用法
尽管函数指针被广泛用于实现函数回调,但C++还提供了一个重要的实现回调函数的方法,那就是函数对象。
functor,翻译成函数对象,伪函数运算符,是重载了“()”操作符的普通类对象。从语法上讲,它与普通函数行为类似。
greater<>与less<>就是函数对象。下面举出greater<int>的简易实现原理。
struct greater
{
bool operator() (const int& iLeft, const int& iRight)
{return (iLeft>iRight); //如果是实现less<int>的话，这边是写return (iLeft<iRight);
}
}
容器就是调用函数对象的operator()方法去比较两个值的大小。题目：学生包含学号，姓名属性，现要求任意插入几个学生对象到set容器中，使得容器中的学生按学号的升序排序。
解：
class CStudent //学生类
{public:CStudent(int iID, string strName){m_iID = iID;m_strName = strName;}int m_iID; //学号string m_strName; //姓名
}
//为保持主题鲜明,本类不写拷贝构造函数,本类也不需要写拷贝构造函数。但大家仍要有考虑拷贝构造函数的习惯。struct StuFunctor //函数对象
{bool operator() (const CStudent &stu1, const CStudent &stu2){return (stu1.m_iID<stu2.m_iID);}
}
void main() //main函数
{set<CStudent, StuFunctor> setStu;setStu.insert(CStudent(3,"小张"));setStu.insert(CStudent(1,"小李"));setStu.insert(CStudent(5,"小王"));setStu.insert(CStudent(2,"小刘"));//此时容器setStu包含了四个学生对象，分别是按姓名顺序的“小李”，“小刘”，“小张”，“小王”
}6). set对象的拷贝构造与赋值
set(const set &st); //拷贝构造函数
set& operator=(const set &st); //重载等号操作符
set.swap(st); //交换两个集合容器set<int> setIntA;setIntA.insert(3);setIntA.insert(1);setIntA.insert(7);setIntA.insert(5);setIntA.insert(9);set<int> setIntB(setIntA); //1 3 5 7 9set<int> setIntC;setIntC = setIntA; //1 3 5 7 9setIntC.insert(6);setIntC.swap(setIntA); //交换7). set的大小
set.size(); //返回容器中元素的数目
set.empty(); //判断容器是否为空set<int> setIntA;setIntA.insert(3);setIntA.insert(1);setIntA.insert(7);setIntA.insert(5);setIntA.insert(9);if (!setIntA.empty()){int iSize = setIntA.size(); //5}8). set的删除、修改
(1)删除
set.clear(); //清除所有元素
set.erase(pos); //删除pos迭代器所指的元素,返回下一个元素的迭代器。
set.erase(beg,end); //删除区间[beg,end)的所有元素,返回下一个元素的迭代器。
set.erase(elem); //删除容器中值为elem的元素。删除区间内的元素
setInt是用set<int>声明的容器，现已包含按顺序的1,3,5,6,9,11元素。
set<int>::iterator itBegin=setInt.begin();
++ itBegin;
set<int>::iterator itEnd=setInt.begin();
++ itEnd;
++ itEnd;
++ itEnd;
setInt.erase(itBegin,itEnd);
//此时容器setInt包含按顺序的1,6,9,11四个元素。删除容器中第一个元素
setInt.erase(setInt.begin()); //6,9,11删除容器中值为9的元素
set.erase(9); 删除setInt的所有元素
setInt.clear(); //容器为空(2)修改
不能直接修改原来容器内数据,所以只能删除某元素再插入所需值。9). set的查找
set.find(elem); //查找elem元素,返回指向elem元素的迭代器。
set.count(elem); //返回容器中值为elem的元素个数。对set来说,要么是0,要么是1。对multiset来说,值可能大于1。
set.lower_bound(elem); //返回第一个>=elem元素的迭代器。
set.upper_bound(elem); //返回第一个>elem元素的迭代器。set.equal_range(elem); //返回容器中与elem相等的上下限的两个迭代器。上限是闭区间，下限是开区间，如[beg,end)。
以上函数返回两个迭代器，而这两个迭代器被封装在pair中。
以下讲解pair的含义与使用方法。
set<int> setInt;setInt.insert(3);setInt.insert(1);setInt.insert(7);setInt.insert(5);setInt.insert(9);set<int>::iterator itA = setInt.find(5);int iA = *itA; //iA == 5int iCount = setInt.count(5); //iCount == 1set<int>::iterator itB = setInt.lower_bound(5);set<int>::iterator itC = setInt.upper_bound(5);int iB = *itB; //iB == 5int iC = *itC; //iC == 7
pair< set<int>::iterator, set<int>::iterator > pairIt = setInt.equal_range(5); //pair是什么？
10).pair的使用
pair译为对组，可以将两个值视为一个单元。
pair<T1,T2>存放的两个值的类型，可以不一样，如T1为int，T2为float。T1,T2也可以是自定义类型。
pair.first是pair里面的第一个值，是T1类型。
pair.second是pair里面的第二个值，是T2类型。set<int> setInt;
... //往setInt容器插入元素1,3,5,7,9
pair< set<int>::iterator , set<int>::iterator > pairIt = setInt.equal_range(5);
set<int>::iterator itBeg = pairIt.first;
set<int>::iterator itEnd = pairIt.second;
//此时 *itBeg==5 而 *itEnd == 711).总结案例:int x;scanf("%ld",&x);multiset<int> h; //建立一个multiset类型，变量名是h，h序列里面存的是int类型,初始h为空while(x!=0)
{h.insert(x); //将x插入h中scanf("%ld",&x);} pair< multiset<int>::iterator , multiset<int>::iterator > pairIt = h.equal_range(22);multiset<int>::iterator itBeg = pairIt.first;multiset<int>::iterator itEnd = pairIt.second;int nBeg = *itBeg;int nEnd = *itEnd;while(!h.empty()) // 序列非空h.empty()==true时表示h已经空了
{multiset<int>::iterator c = h.begin(); //c指向h序列中第一个元素的地址，第一个元素是最小的元素printf("%ld ",*c); //将地址c存的数据输出h.erase(c); //从h序列中将c指向的元素删除}
Map和multimap容器
1).map/multimap的简介(#include <map>)
*map是标准的关联式容器，一个map是一个键值对序列，即(key,value)对。它提供基于key的快速检索能力。
*map中key值是唯一的。集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。
*map的具体实现采用红黑树变体的平衡二叉树的数据结构。在插入操作和删除操作上比vector快。
*map可以直接存取key所对应的value，支持[]操作符，如map[key]=value。
*multimap与map的区别:map支持唯一键值，每个键只能出现一次;而multimap中相同键可以出现多次。multimap不支持[]操作符。2). map/multimap对象的默认构造
map/multimap采用模板类实现,对象的默认构造形式:
map<T1,T2> mapTT;
multimap<T1,T2> multimapTT;
如:
map<int, char> mapA;
map<string,float> mapB;
//其中T1,T2还可以用各种指针类型或自定义类型3). map的插入与迭代器
map.insert(...); //往容器插入元素，返回pair<iterator,bool>
在map中插入元素的三种方式：
假设 map<int, string> mapStu;
一、通过pair的方式插入对象
mapStu.insert( pair<int,string>(3,"小张") );
二、通过pair的方式插入对象
mapStu.inset(make_pair(-1, “校长-1”));
三、通过value_type的方式插入对象
mapStu.insert( map<int,string>::value_type(1,"小李") );
四、通过数组的方式插入值
mapStu[3] = “小刘";
mapStu[5] = “小王"；前三种方法，采用的是insert()方法，该方法返回值为pair<iterator,bool>
第四种方法非常直观，但存在一个性能的问题。插入3时，先在mapStu中查找主键为3的项，若没发现，则将一个键为3，值为初始化值的对组插入到mapStu中，然后再将值修改成“小刘”。若发现已存在3这个键，则修改这个键对应的value。
string strName = mapStu[2]; //取操作或插入操作
只有当mapStu存在2这个键时才是正确的取操作，否则会自动插入一个实例，键为2，值为初始化值。假设 map<int, string> mapA;
pair< map<int,string>::iterator, bool > pairResult = mapA.insert(pair<int,string>(3,"小张")); //插入方式一int iFirstFirst = (pairResult.first)->first; //iFirst == 3;
string strFirstSecond = (pairResult.first)->second; //strFirstSecond为"小张"
bool bSecond = pairResult.second; //bSecond == true;mapA.insert(map<int,string>::value_type(1,"小李")); //插入方式二mapA[3] = "小刘"; //修改value
mapA[5] = "小王"; //插入方式三string str1 = mapA[2]; //执行插入 string() 操作，返回的str1的字符串内容为空。
string str2 = mapA[3]; //取得value，str2为"小刘"//迭代器遍历for (map<int,string>::iterator it=mapA.begin(); it!=mapA.end(); ++it){pair<int, string> pr = *it;int iKey = pr.first;string strValue = pr.second;}
map.rbegin()与map.rend() 略。map<T1,T2,less<T1> > mapA; //该容器是按键的升序方式排列元素。未指定函数对象，默认采用less<T1>函数对象。
map<T1,T2,greater<T1>> mapB; //该容器是按键的降序方式排列元素。
less<T1>与greater<T1> 可以替换成其它的函数对象functor。
可编写自定义函数对象以进行自定义类型的比较，使用方法与set构造时所用的函数对象一样。
map.begin(); //返回容器中第一个数据的迭代器。
map.end(); //返回容器中最后一个数据之后的迭代器。
map.rbegin(); //返回容器中倒数第一个元素的迭代器。
map.rend(); //返回容器中倒数最后一个元素的后面的迭代器。
4). map对象的拷贝构造与赋值
map(const map &mp); //拷贝构造函数
map& operator=(const map &mp); //重载等号操作符
map.swap(mp); //交换两个集合容器
例如:map<int, string> mapA;mapA.insert(pair<int,string>(3,"小张")); mapA.insert(pair<int,string>(1,"小杨")); mapA.insert(pair<int,string>(7,"小赵")); mapA.insert(pair<int,string>(5,"小王")); map<int ,string> mapB(mapA); //拷贝构造map<int, string> mapC;mapC = mapA; //赋值mapC[3] = "老张";mapC.swap(mapA); //交换
5).map的大小
map.size(); //返回容器中元素的数目
map.empty(); //判断容器是否为空map<int, string> mapA;mapA.insert(pair<int,string>(3,"小张")); mapA.insert(pair<int,string>(1,"小杨")); mapA.insert(pair<int,string>(7,"小赵")); mapA.insert(pair<int,string>(5,"小王")); if (mapA.empty()){int iSize = mapA.size(); //iSize == 4}
6).map的删除
map.clear(); //删除所有元素
map.erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
map.erase(beg,end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
map.erase(keyElem); //删除容器中key为keyElem的对组。
map<int, string> mapA;mapA.insert(pair<int,string>(3,"小张")); mapA.insert(pair<int,string>(1,"小杨")); mapA.insert(pair<int,string>(7,"小赵")); mapA.insert(pair<int,string>(5,"小王")); //删除区间内的元素map<int,string>::iterator itBegin=mapA.begin();++ itBegin;++ itBegin;map<int,string>::iterator itEnd=mapA.end();mapA.erase(itBegin,itEnd); //此时容器mapA包含按顺序的{1,"小杨"}{3,"小张"}两个元素。mapA.insert(pair<int,string>(7,"小赵")); mapA.insert(pair<int,string>(5,"小王")); //删除容器中第一个元素mapA.erase(mapA.begin()); //此时容器mapA包含了按顺序的{3,"小张"}{5,"小王"}{7,"小赵"}三个元素//删除容器中key为5的元素mapA.erase(5); //删除mapA的所有元素mapA.clear(); //容器为空7). map的查找
map.find(key); //查找键key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回map.end();
map.count(keyElem); //返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。
map<int,string>::iterator it=mapStu.find(3);
if(it == mapStu.end())
{//没找到
}
else
{//找到了pair<int, string> pairStu = *it;int iID = pairStu.first; //或 int iID = it->first;string strName = pairStu.second; //或 string strName = it->second;
}map.lower_bound(keyElem); //返回第一个key>=keyElem元素的迭代器。
map.upper_bound(keyElem); //返回第一个key>keyElem元素的迭代器。
例如： mapStu是用map<int,string>声明的容器，已包含{1,"小李"}{3,"小张"}{5,"小王"}{7,"小赵"}{9,"小陈"}元素。map<int,string>::iterator it;
it = mapStu.lower_bound(5); //it->first==5 it->second=="小王"
it = mapStu.upper_bound(5); //it->first==7 it->second=="小赵"
it = mapStu.lower_bound(6); //it->first==7 it->second=="小赵"
it = mapStu.upper_bound(6); //it->first==7 it->second=="小赵"map.equal_range(keyElem); //返回容器中key与keyElem相等的上下限的两个迭代器。上限是闭区间，下限是开区间，如[beg,end)。以上函数返回两个迭代器，而这两个迭代器被封装在pair中。例如 map<int,string> mapStu;
... //往mapStu容器插入元素{1,"小李"}{3,"小张"}{5,"小王"}{7,"小赵"}{9,"小陈"}
pair< map<int,string>::iterator , map<int,string>::iterator > pairIt = mapStu.equal_range(5);
map<int, string>::iterator itBeg = pairIt.first;
map<int, string>::iterator itEnd = pairIt.second;
//此时 itBeg->first==5 , itEnd->first == 7,
itBeg->second=="小王", itEnd->second=="小赵"Multimap 案例:
//1个key值可以对应多个valude =分组
//公司有销售部 sale （员工2名）、技术研发部 development （1人）、财务部 Financial （2人）
//人员信息有：姓名，年龄，电话、工资等组成
//通过 multimap进行 信息的插入、保存、显示
//分部门显示员工信息
关注
笔者 - jxd
微信公众号搜索 “码农总动员” 或 微信扫描下方二维码，了解更多你不知道的XX，O(∩_∩)O
更多推荐
C++ —— STL
发布评论