1 STL的string
1 String概念
- string是STL的字符串类型，通常用来表示字符串。而在使用string之前，字符串通常是用char*表示的。string与char*都可以用来表示字符串，那么二者有什么区别呢。
string和char*的比较
- string是一个类, char*是一个指向字符的指针。
string封装了char*，管理这个字符串，是一个char*型的容器。
- string不用考虑内存释放和越界。
string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等。
- string提供了一系列的字符串操作函数（这个等下会详讲）
查找find，拷贝copy，删除erase，替换replace，插入insert
2string的构造函数
- 默认构造函数：
string(); //构造一个空的字符串string s1。
- 拷贝构造函数：
string(const string &str); //构造一个与str一样的string。如string s1(s2)。
- 带参数的构造函数
string(const char *s); //用字符串s初始化
string(int n,char c); //用n个字符c初始化
3string的存取字符操作
-
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'结尾的字符串的首地址
//但是要用到强制类型转化,不然直接给你输出字符串而不是地址.
列：cout<<"s2地址:"<<static_cast<const void *>(s2.c_str())<<endl;
c_str是一个标准函数，不是自定义函数；
5把string拷贝到char*指向的内存空间的操作
- int copy(char *s, int n, int pos=0) const;
把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目。注意要保证s所指向的空间足够大以容纳当前字符串，不然会越界。
6string的长度
int length() const; //返回当前字符串的长度。长度不包括字符串结尾的'\0'。
bool empty() const; //当前字符串是否为空
7string的赋值
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个字符赋给当前字符串
8string字符串连接
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
9string的比较
int compare(const string &s) const; //与字符串s比较
int compare(const char *s) const; //与字符串s比较
compare函数在>时返回 1，<时返回 -1，==时返回 0。比较区分大小写，比较时参考字典顺序，排越前面的越小。大写的A比小写的a小。
10string的子串
string substr(int pos=0, int n=npos) const; //返回由pos开始的n个字符组成的子字符串
11string的查找 和 替换
查找
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在当前字符串中的位置
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
//是先删除，在插入；不计算结束符'\0'。
void swap(string &s2); //交换当前字符串与s2的值，注意，此函数不支持链式编程，因为它没有返回值
//4 字符串的查找和替换
void main()
{
string s1 = "wbm hello wbm 111 wbm 222 wbm 333";
size_t index = s1.find("wbm", 0);
cout << "index: " << index;
//求itcast出现的次数
size_t offindex = s1.find("wbm", 0);
while (offindex != string::npos)
{
cout << "在下标index: " << offindex << "找到wbm\n";
offindex = offindex + 1;
offindex = s1.find("wbm", offindex);
}
//替换
string s2 = "wbm hello wbm 111 wbm 222 wbm 333";
sreplace(0, 3, "wbm");
cout << s2 << endl;
//求itcast出现的次数
offindex = sfind("wbm", 0);
while (offindex != string::npos)
{
cout << "在下标index: " << offindex << "找到wbm\n";
sreplace(offindex, 3, "WBM");
offindex = offindex + 1;
offindex = s1.find("wbm", offindex);
}
cout << "替换以后的s2：" << s2 << endl;
}
12String的区间删除和插入
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个字符，返回修改后的字符串
13string算法相关
void main()
{
string s2 = "AAAbbb";
transform(s2.begin(), s2.end(), s2.begin(), toupper);
//将输入的操作作用与指定范围内的每个元素，并产生一个新的序列。重载版本将操作作用在一对元素上，另外一个元素来自输入的另外一个序列。结果输出到指定容器 （头文件：algorithm）
//另外，需要指出的是：在Linux下面，toupper和tolower是宏定义实现，而不是函数实现。所以这个在Linux下面会出错。
cout << s2 << endl;
string s3 = "AAAbbb";
transform(s3.begin(), s3.end(), s3.begin(), tolower);
cout << s3 << endl;
}
Linux下的版本：
|
char to_toupper(char c) { return toupper(c); } char to_tolower(char c) { return totolower(c); } void main() { string s2 = "AAAbbb"; transform(s2.begin(), s2.end(), s2.begin(), to_toupper);
cout << s2 << endl;
string s3 = "AAAbbb"; transform(s3.begin(), s3.end(), s3.begin(), to_tolower); cout << s3 << endl; } |
2 Vector容器
1Vector容器简介
- vector是将元素置于一个动态数组中加以管理的容器。
- vector可以随机存取元素（支持索引值直接存取， 用[]操作符或at()方法，这个等下会详讲）。
vector尾部添加或移除元素非常快速。但是在中部或头部插入元素或移除元素比较费时
2vector对象的默认构造
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对象间拷贝正常。
3vector对象的带参数构造
理论知识
- 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);
4vector的赋值
理论知识
- vector.assign(beg,end); //将[beg, end)区间中的数据拷贝赋值给本身。注意该区间是左闭右开的区间。
- vector.assign(n,elem); //将n个elem拷贝赋值给本身。
- vector& operator=(const vector &vec); //重载等号操作符
- vector.swap(vec); // 将vec与本身的元素互换。
- 使用[]和at()可以单个赋值；
vector<int> vecIntA, vecIntB, vecIntC, vecIntD;
int iArray[] = {0,1,2,3,4};
vecIntA.assign(iArray,iArray+5);
vecIntB.assign( vecIntA.begin(), vecIntA.end() ); //用其它容器的迭代器作参数。
vecIntC.assign(3,9);
vector<int> vecIntD;
vecIntD = vecIntA;
vecIntA.swap(vecIntD);
5vector的大小
理论知识
- vector.size(); //返回容器中元素的个数
- vector.empty(); //判断容器是否为空
- vector.resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
-
vector.resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
//是拓展到num那么长，而不是重新拓展（即删除在拓展）。
例如 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元素。
6vector末尾的添加移除操作
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(); //移除容器中最后一个元素
vecInt.pop_back();
//{5 ,7 ,9}
7vector的数据存取
理论知识
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}
8迭代器基本原理
- 迭代器是一个"可遍历STL容器内全部或部分元素"的对象。
- 迭代器指出容器中的一个特定位置。
- 迭代器就如同一个指针。
- 迭代器提供对一个容器中的对象的访问方法，并且可以定义了容器中对象的范围。
- 这里大概介绍一下迭代器的类别。
输入迭代器：也有叫法称之为"只读迭代器"，它从容器中读取元素，只能一次读入一个元素向前移动，只支持一遍算法，同一个输入迭代器不能两遍遍历一个序列。
输出迭代器：也有叫法称之为"只写迭代器"，它往容器中写入元素，只能一次写入一个元素向前移动，只支持一遍算法，同一个输出迭代器不能两遍遍历一个序列。
正向迭代器：组合输入迭代器和输出迭代器的功能，还可以多次解析一个迭代器指定的位置，可以对一个值进行多次读/写。
双向迭代器：组合正向迭代器的功能，还可以通过--操作符向后移动位置。
随机访问迭代器：组合双向迭代器的功能，还可以向前向后跳过任意个位置，可以直接访问容器中任何位置的元素。
- 目前本系列教程所用到的容器，都支持双向迭代器或随机访问迭代器，下面将会详细介绍这两个类别的迭代器。
9双向迭代器与随机访问迭代器
双向迭代器支持的操作：
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支持随机访问迭代器。
10vector与迭代器的配合使用
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。
当我使用函数模板来使用迭代器的时候：比如这样：↓
|
template <typename T> void out(vector<T> &cer ) { for(typename vector<T>::iterator it=cer.begin();it!=cer.end();++it ) cout<<*it<<endl; } |
看到那个突出的地方了嘛？那是必须的（我在Linux下面测试的，vs下我就不清楚了。）另外，只读迭代器应该用const_iterator，避免被意外的改变；
11vector的插入
理论知识
- 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(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}
12vector的删除
理论知识
- 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(); //容器为空
13vector小结
这一讲，主要讲解如下要点：
容器的简介，容器的分类，各个容器的数据结构
vector,deque,list,set,multiset,map,multimap
容器vector的具体用法（包括迭代器的具体用法）。
vertor简介，vector使用之前的准备，vector对象的默认构造，vector末尾的添加移除操作，vector的数据存取，迭代器的简介，双向迭代器与随机访问迭代器
vector与迭代器的配合使用，vector对象的带参数构造，vector的赋值，vector的大小，vector的插入，vector的删除。
3 Deque容器
Deque简介
- deque是"double-ended queue"的缩写，和vector一样都是STL的容器，deque是双端数组，而vector是单端的。
- deque在接口上和vector非常相似，在许多操作的地方可以直接替换。
- deque可以随机存取元素（支持索引值直接存取， 用[]操作符或at()方法，这个等下会详讲）。
- deque头部和尾部添加或移除元素都非常快速。但是在中部安插元素或移除元素比较费时。
- #include <deque>
deque对象的默认构造
deque采用模板类实现，deque对象的默认构造形式：deque<T> deqT;
deque <int> deqInt; //一个存放int的deque容器。
deque <float> deq Float; //一个存放float的deque容器。
deque <string> deq String; //一个存放string的deque容器。
...
//尖括号内还可以设置指针类型或自定义类型。
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}
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); //1
int iB = deqInt[1]; //3
deqInt.at(0) = 99; //99
deqInt[1] = 88; //88
int iFront = deqInt.front(); //99
int iBack = deqInt.back(); //9
deqInt.front() = 77; //77
deqInt.back() = 66; //66
deque与迭代器
理论知识
- deque.begin(); //返回容器中第一个元素的迭代器。
- deque.end(); //返回容器中最后一个元素之后的迭代器。
- deque.rbegin(); //返回容器中倒数第一个元素的迭代器。
- deque.rend(); //返回容器中倒数最后一个元素之后的迭代器。
deque<int> deqInt;
deqInt.push_back(1);
deqInt.push_back(3);
deqInt.push_back(5);
deqInt.push_back(7);
deqInt.push_back(9);
for (deque<int>::iterator it=deqInt.begin(); it!=deqInt.end(); ++it)
{
cout << *it;
cout << "";
}
// 1 3 5 7 9
for (deque<int>::reverse_iterator rit=deqInt.rbegin(); rit!=deqInt.rend(); ++rit)
{
cout << *rit;
cout << "";
}
//9 7 5 3 1
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 9
deque<int> deqIntC(5,8); //8 8 8 8 8
deque<int> deqIntD(deqIntA); //1 3 5 7 9
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 8
deqIntD = deqIntA; //1 3 5 7 9
deqIntC.swap(deqIntD); //互换
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(); //3
if (!deqIntA.empty())
{
deqIntA.resize(5); //1 3 5 0 0
deqIntA.resize(7,1); //1 3 5 0 0 1 1
deqIntA.resize(2); //1 3
}
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}
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(); //容器为空
4 stack容器
Stack简介
- stack是堆栈容器，是一种"先进后出"的容器。
- stack是简单地装饰deque容器而成为另外的一种容器。
- #include <stack>
stack对象的默认构造
stack采用模板类实现， stack对象的默认构造形式： stack <T> stkT;
stack <int> stkInt; //一个存放int的stack容器。
stack <float> stkFloat; //一个存放float的stack容器。
stack <string> stkString; //一个存放string的stack容器。
...
//尖括号内还可以设置指针类型或自定义类型。
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,5
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; //赋值
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(); //9
stkIntA.top() = 19; //19
stack的大小
- stack.empty(); //判断堆栈是否为空
- stack.size(); //返回堆栈的大小
stack<int> stkIntA;
stkIntA.push(1);
stkIntA.push(3);
stkIntA.push(5);
stkIntA.push(7);
stkIntA.push(9);
if (!stkIntA.empty())
{
int iSize = stkIntA.size(); //5
}
5 Queue容器
Queue简介
- queue是队列容器，是一种"先进先出"的容器。
- queue是简单地装饰deque容器而成为另外的一种容器。
- #include <queue>
queue对象的默认构造
queue采用模板类实现，queue对象的默认构造形式：queue<T> queT; 如：
queue<int> queInt; //一个存放int的queue容器。
queue<float> queFloat; //一个存放float的queue容器。
queue<string> queString; //一个存放string的queue容器。
...
//尖括号内还可以设置指针类型或自定义类型。
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
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; //赋值
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(); //1
int iBack = queIntA.back(); //9
queIntA.front() = 11; //11
queIntA.back() = 19; //19
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
}
6 List容器
List简介
- list是一个双向链表容器，可高效地进行插入删除元素。
- list不可以随机存取元素，所以不支持at.(pos)函数与[]操作符。It++(ok) it+5(err)
- #include <list>
list对象的默认构造
list采用采用模板类实现,对象的默认构造形式：list<T> lstT; 如：
list<int> lstInt; //定义一个存放int的list容器。
list<float> lstFloat; //定义一个存放float的list容器。
list<string> lstString; //定义一个存放string的list容器。
...
//尖括号内还可以设置指针类型或自定义类型。
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}
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(); //1
int iBack = lstInt.back(); //9
lstInt.front() = 11; //11
lstInt.back() = 19; //19
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 << " ";
}
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 9
list<int> lstIntC(5,8); //8 8 8 8 8
list<int> lstIntD(lstIntA); //1 3 5 7 9
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 9
lstIntC.assign(5,8); //8 8 8 8 8
lstIntD = lstIntA; //1 3 5 7 9
lstIntC.swap(lstIntD); //互换
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(); //3
lstIntA.resize(5); //1 3 5 0 0
lstIntA.resize(7,1); //1 3 5 0 0 1 1
lstIntA.resize(2); //1 3
}
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}
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(); //容器为空
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
小结:
- 一、容器deque的使用方法
适合 在头尾添加移除元素。使用方法与vector类似。
- 二、容器queue,stack的使用方法
适合队列，堆栈的操作方式。
- 三、容器list的使用方法
适合在任意位置快速插入移除元素
7优先级队列priority_queue
- 最大值优先级队列、最小值优先级队列
- 优先级队列适配器 STL priority_queue
- 用来开发一些特殊的应用,请对stl的类库,多做扩展性学习
priority_queue<int, deque<int>> pq;
priority_queue<int, vector<int>> pq;
pq.empty()
pq.size()
pq.top()
pq.pop()
pq.push(item)
#include <iostream>
using namespace std;
#include "queue"
void main()
{
priority_queue<int> p1; //默认是 最大值优先级队列
//priority_queue<int, vector<int>, less<int> > p1; //相当于这样写
priority_queue<int, vector<int>, greater<int>> p2; //最小值优先级队列
p1.push(33);
p1.push(11);
p1.push(55);
p1.push(22);
cout <<"队列大小" << p1.size() << endl;
cout <<"队头" << p1.top() << endl;
while (p1.size() > 0)
{
cout << p1.top() << " ";
p1.pop();
}
cout << endl;
cout << "测试 最小值优先级队列" << endl;
ppush(33);
ppush(11);
ppush(55);
ppush(22);
while (psize() > 0)
{
cout << ptop() << " ";
ppop();
}
}
8 Set和multiset容器
set/multiset的简介
- set是一个集合容器，其中所包含的元素是唯一的，集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。
- set采用红黑树变体的数据结构实现，红黑树属于平衡二叉树。在插入操作和删除操作上比vector快。
- set不可以直接存取元素。（不可以使用at.(pos)与[]操作符）。
- multiset与set的区别：set支持唯一键值，每个元素值只能出现一次；而multiset中同一值可以出现多次。
- 不可以直接修改set或multiset容器中的元素值，因为该类容器是自动排序的。如果希望修改一个元素值，必须先删除原有的元素，再插入新的元素。
- #include <set>
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容器。
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()。略。
Set集合的元素排序
- 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元素
函数对象functor的用法
- 尽管函数指针被广泛用于实现函数回调，但C++还提供了一个重要的实现回调函数的方法，那就是函数对象。
- functor，翻译成函数对象，伪函数，算符，是重载了"()"操作符的普通类对象。从语法上讲，它与普通函数行为类似。
- greater<>与less<>就是函数对象。
- 下面举出greater<int>的简易实现原理。
下面举出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<stum_iID);
}
}
//main函数
void main()
{
set<CStudent, StuFunctor> setStu;
setStu.insert(CStudent(3,"小张"));
setStu.insert(CStudent(1,"小李"));
setStu.insert(CStudent(5,"小王"));
setStu.insert(CStudent(2,"小刘"));
//此时容器setStu包含了四个学生对象，分别是按姓名顺序的"小李"，"小刘"，"小张"，"小王"
}
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 9
set<int> setIntC;
setIntC = setIntA; //1 3 5 7 9
setIntC.insert(6);
setIntC.swap(setIntA); //交换
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
}
set的删除
- 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(); //容器为空
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 == 5
int iCount = setInt.count(5); //iCount == 1
set<int>::iterator itB = setInt.lower_bound(5);
set<int>::iterator itC = setInt.upper_bound(5);
int iB = *itB; //iB == 5
int iC = *itC; //iC == 7
pair< set<int>::iterator, set<int>::iterator > pairIt = setInt.equal_range(5); //pair是什么？
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 == 7
小结
- 一、容器set/multiset的使用方法；
红黑树的变体，查找效率高，插入不能指定位置，插入时自动排序。
- 二、functor的使用方法；
类似于函数的功能，可用来自定义一些规则，如元素比较规则。
- 三、pair的使用方法。
对组，一个整体的单元，存放两个类型(T1,T2，T1可与T2一样)的两个元素。
案例:
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指向的元素删除
}
9 Map和multimap容器
map/multimap的简介
- map是标准的关联式容器，一个map是一个键值对序列，即(key,value)对。它提供基于key的快速检索能力。
- map中key值是唯一的。集合中的元素按一定的顺序排列。元素插入过程是按排序规则插入，所以不能指定插入位置。
- map的具体实现采用红黑树变体的平衡二叉树的数据结构。在插入操作和删除操作上比vector快。
- map可以直接存取key所对应的value，支持[]操作符，如map[key]=value。
- multimap与map的区别：map支持唯一键值，每个键只能出现一次；而multimap中相同键可以出现多次。multimap不支持[]操作符。
- #include <map>
map/multimap对象的默认构造
map/multimap采用模板类实现，对象的默认构造形式：
map<T1,T2> mapTT;
multimap<T1,T2> multimapTT;
如：
map<int, char> mapA;
map<string,float> mapB;
//其中T1,T2还可以用各种指针类型或自定义类型
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(); //返回容器中倒数最后一个元素的后面的迭代器。
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); //交换
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
}
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(); //容器为空
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; } |
例如： 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=="小赵" |
以上函数返回两个迭代器，而这两个迭代器被封装在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进行 信息的插入、保存、显示 //分部门显示员工信息 |
10 容器共性机制研究
10.1容器的共通能力
C++模板是容器的概念。
理论提高：所有容器提供的都是值（value）语意，而非引用（reference）语意。容器执行插入元素的操作时，内部实施拷贝动作。所以STL容器内存储的元素必须能够被拷贝（必须提供拷贝构造函数）。
- 除了queue与stack外，每个容器都提供可返回迭代器的函数，运用返回的迭代器就可以访问元素。
- 通常STL不会丢出异常。要求使用者确保传入正确的参数。
- 每个容器都提供了一个默认构造函数跟一个默认拷贝构造函数。
- 如已有容器vecIntA。
- vector<int> vecIntB(vecIntA); //调用拷贝构造函数，复制vecIntA到vecIntB中。
-
与大小相关的操作方法(c代表容器)：
c.size(); //返回容器中元素的个数
c.empty(); //判断容器是否为空
-
比较操作(c1,c2代表容器)：
c1 == c2 判断c1是否等于c2
c1 != c2 判断c1是否不等于c2
c1 = c2 把c2的所有元素指派给c1
10.2各个容器的使用时机
- Vector的使用场景：比如软件历史操作记录的存储，我们经常要查看历史记录，比如上一次的记录，上上次的记录，但却不会去删除记录，因为记录是事实的描述。
- deque的使用场景：比如排队购票系统，对排队者的存储可以采用deque，支持头端的快速移除，尾端的快速添加。如果采用vector，则头端移除时，会移动大量的数据，速度慢。
- vector与deque的比较：
- 一：vector.at()比deque.at()效率高，比如vector.at(0)是固定的，deque的开始位置却是不固定的。
- 二：如果有大量释放操作的话，vector花的时间更少，这跟二者的内部实现有关。
- 三：deque支持头部的快速插入与快速移除，这是deque的优点。
- list的使用场景：比如公交车乘客的存储，随时可能有乘客下车，支持频繁的不确实位置元素的移除插入。
- set的使用场景：比如对手机游戏的个人得分记录的存储，存储要求从高分到低分的顺序排列。
- map的使用场景：比如按ID号存储十万个用户，想要快速要通过ID查找对应的用户。二叉树的查找效率，这时就体现出来了。如果是vector容器，最坏的情况下可能要遍历完整个容器才能找到该用户。