【C++13】C++容器之string,vector,deque
C风格字符串(以空字符结尾的字符数组)太过复杂难于掌握，不适合大程序的开发，所以C++标准库定义了一种string类，定义在头文件<string>。
String和c风格字符串对比：
- Char*是一个指针，String是一个类 ： string封装了char*，管理这个字符串，是一个char*型的容器。
- String封装了很多实用的成员方法 ： 查找find，拷贝copy，删除delete 替换replace，插入insert
- 不用考虑内存释放和越界 ： string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等。
1、string
1 构造、赋值
void test01()
string str2 = "abc";
string str3(str2);
string str4(10, 'a');
cout << "str2 = " << str2 << endl;
cout << "str3 = " << str3 << endl;
cout << "str4 = " << str4 << endl;
赋值操作
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个字符赋值给字符串
void test02()
string str;
str.assign("abcde", 3);
cout << str << endl;
string str2;
str2.assign(str);
cout << str2 << endl;
str2.assign(str, 0, 2); string& assign(const string & s, int start, int n);//将s从start开始n个字符赋值给字符串
cout << str2 << endl;
2 []、at 字符存取
[] 和 at区别？ []访问越界 直接挂掉，at抛出out_of_range异常
void test03()
string str = "hello world";
//for (int i = 0; i < str.size();i++)
// //cout << str[i] << endl;
// cout << str.at(i) << endl; //和上面效果一样
//[]和at区别，[]访问越界 直接挂掉 ， at访问越界 抛出out_of_range异常
//cout << str[100] << endl;
cout << str.at(100) << endl;
catch (out_of_range& e)
cout << e.what() << endl;
catch (...)
cout << "异常捕获" << endl;
3 字符串拼接 += append
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
- += 运算符：可以追加完整字符串。
- append 函数：也允许追加完整字符串。
- push_back 函数：不允许追加完整字符串。
具体见 https:// blog.csdn.net/qq_385375 03/article/details/106279850
4 查找和替换
查找 find rfind(从右往左查找) 替换 replace
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
//例子查找
string str = "abcdefgde";
int pos = str.find("de");
//例子：替换
str.replace(1, 3, "11111");
5 比较 compare
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较
compare函数在>时返回 1，<时返回 -1，==时返回 0。
比较区分大小写，比较时参考字典顺序，排越前面的越小。
大写的A比小写的a小。
if (str1.compare(str2) == 0)
6 子串 substr
string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
7 插入 insert 删除 erase
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个字符
//举例插入：
string str = "hello";
str.insert(1, "111"); //h111ello
str.erase(1, 3);
#include<string>
#include<iostream>
using namespace std;
int main ()
string str ("This is an example phrase.");
string::iterator it;
//第（1）种方法
str.erase (10,8);
cout << str << endl; // "This is an phrase."
//第（2）种方法
it=str.begin()+9;
str.erase (it);
cout << str << endl; // "This is a phrase."
//第（3）种方法
str.erase (str.begin()+5, str.end()-7);
cout << str << endl; // "This phrase."
return 0;
8 字符串尾部插入
//string中也有这个函数，作用是字符串之后插入一个字符。
//用法例如：
string name="XQ";
name.push_back('W');
//name的结果变为：
name=XQW
9 string 和 const char* 转换
- string 转 const char * .c_str();
- const char * 转string 利用string 有参构造
- const char *可以隐式转换为 string 反之不可以
//string 转 char*
string str = "itcast";
const char* cstr = str.c_str();
//char* 转 string
char* s = "itcast";
string str(s);
案例
- 求email中的用户名
- string str = " http://www. itcast.com.cn ";
- 将 www itcast com cn 单词截取到 vector容器中
void test06()
string email = "zhangtao@sina.com";
int pos = email.find("@"); // 8
string userName = email.substr(0, pos);
cout << userName << endl;
//解析字符串
void test07()
string str = "www.itcast.com.cn";
vector<string> v; //将 www itcast com cn 单词截取到 vector容器中
int start = 0;
int pos = -1;
while (true)
//www.itcast.com.cn
pos = str.find(".", start);
if (pos == -1)
//将cn截取出来
string tempStr = str.substr(start, str.size() - start);
v.push_back(tempStr);
break;
string tempStr = str.substr(start, pos - start);
v.push_back(tempStr);
start = pos + 1;
for (vector<string>::iterator it = v.begin(); it != v.end(); it++)
cout << *it << endl;
2、vector 容器
1 vector 容器基本概念
vector的数据安排以及操作方式，与array非常相似，两者的唯一差别在于空间的运用的灵活性。
- Array是静态空间，一旦配置了就不能改变，要换大一点或者小一点的空间，比较繁琐：配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。
- Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。
2 vector 的数据结构
Vector所采用的数据结构非常简单，线性连续空间，它以两个迭代器_Myfirst和_Mylast分别指向配置得来的连续空间中目前已被使用的范围，并以迭代器_Myend指向整块连续内存空间的尾端。
为了降低空间配置时的速度成本，vector实际配置的大小可能比客户端需求大一些，以备将来可能的扩充。换句话说，一个vector的容量永远大于或等于其大小，一旦容量等于大小，便是满载，下次再有新增元素，整个vector容器就得另觅居所。
注意：所谓动态增加大小，并不是在原空间之后续接新空间(因为无法保证原空间之后尚有可配置的空间)，而是一块更大的内存空间，然后将原数据拷贝新空间，并释放原空间。因此，对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有迭代器就都失效了。这是程序员容易犯的一个错误，务必小心。
void test01()
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
cout << v.capacity() << endl; // v.capacity()容器的容量
并不是倍数增加。
3 接口
1）构造、赋值
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));
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
vector& operator=(const vector &vec);//重载等号操作符
swap(vec);// 将vec与本身的元素互换。
void printVector(vector<int>& v)
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
cout << *it << " ";
cout << endl;
void test02()
vector<int>v1;
v1.push_back(10);
v1.push_back(20);
v1.push_back(30);
v1.push_back(40);
v1.push_back(50);
vector<int>v2(v1.begin(), v1.end());
printVector(v2);
vector<int>v3;
v3.assign(v1.begin(), v1.end());
printVector(v3);
vector<int>v4(10, 100);
printVector(v4);
cout << "v3和v4互换后：" << endl;
v3.swap(v4);
printVector(v3);
printVector(v4);
2）vector 大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。
capacity();//容器的容量
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
3）vector 数据存取操作
at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
operator[];//返回索引idx所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素
4）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();//删除容器中所有元素
void test04()
vector<int>v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.insert(v.begin(), 100);
printVector(v);
v.push_back(1000);
printVector(v);
v.pop_back();
printVector(v);
v.erase(v.begin());
printVector(v);
v.clear(); //v.erase(v.begin(), v.end()); 等价于 v.clear();
printVector(v);
案例：巧用swap收缩内存
//案例1 巧用swap收缩内存
void test05()
vector<int>v;
for (int i = 0; i < 100000; i++)
v.push_back(i);
cout << "v.capacity = " << v.capacity() << endl;
cout << "v.size = " << v.size() << endl;
v.resize(3);
cout << "v.capacity = " << v.capacity() << endl;
cout << "v.size = " << v.size() << endl;
//巧用swap收缩内存
vector<int>(v).swap(v);
cout << "v.capacity = " << v.capacity() << endl;
cout << "v.size = " << v.size() << endl;
capacity是分配的空间大小，size是数据大小。
理解如下图：vector<int>(v).swap(v); 用v初始化一个匿名对象，再进行交换，再释放原来空间。
案例2: ： 巧用 reserve 预留内存
//案例2 巧用 reserve 预留空间
void test06()
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 = " << num << endl;
num表示记录重新分配内存的次数。若没有v.reserve(100000); ，分配次数约位30次。这里只用1次。
判断容器的迭代器是否支持随机访问
void test07()
vector<int>v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.push_back(50);
//逆序遍历
for (vector<int>::reverse_iterator it = v.rbegin(); it != v.rend(); it++)
cout << *it << endl;
//vector的迭代器是随机访问迭代器，支持跳跃访问
vector<int>::iterator itBegin = v.begin();
itBegin = itBegin + 3;
cout << *itBegin << endl;
list<int>L;
L.push_back(10);
L.push_back(20);
L.push_back(30);
list<int>::iterator itBegin2 = L.begin();
//itBegin2 = itBegin2 + 1; //报错，list容器的迭代器是不支持随机访问的
3、deque容器
1 deque 容器基本概念
Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。
Deque容器和vector容器最大的差异：
- deque允许使用常数项时间对头端进行元素的插入和删除操作。
- deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，换句话说，像vector那样，”旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间”这样的事情在deque身上是不会发生的。也因此，deque没有必须要提供所谓的空间保留(reserve)功能。
虽然deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指针，其复杂度和vector不是一个量级，这当然影响各个运算的层面。因此，除非有必要，我们应该尽可能的使用vector。对deque进行的排序操作，为了最高效率，可将deque先完整的复制到一个vector中，对vector容器进行排序，再复制回deque.
2 deque 容器实现原理
Deque是由一段一段的定量的连续空间构成。一旦有必要在deque前端或者尾端增加新的空间，便配置一段连续定量的空间，串接在deque的头端或者尾端。Deque最大的工作就是维护这些分段连续的内存空间的整体性的假象，并提供随机存取的接口，避开了重新配置空间，复制，释放的轮回，代价就是复杂的迭代器架构。
既然deque是分段连续内存空间，那么就必须有中央控制，维持整体连续的假象，数据结构的设计及迭代器的前进后退操作颇为繁琐。Deque代码的实现远比vector或list都多得多。
Deque采取一块所谓的map(注意，不是STL的map容器)作为主控，这里所谓的map是一小块连续的内存空间，其中每一个元素(此处成为一个结点)都是一个指针，指向另一段连续性内存空间，称作缓冲区。缓冲区才是deque的存储空间的主体。
3 deque 常用 API
1）deque构造函数
deque<T> deqT;//默认构造形式
deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem);//构造函数将n个elem拷贝给本身。
deque(const deque &deq);//拷贝构造函数。
2) deque赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
deque& operator=(const deque &deq); //重载等号操作符
swap(deq);// 将deq与本身的元素互换
3) 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 = 1000;为了防止修改，使用了只读迭代器
cout << *it << " ";
cout << endl;
void test01()
deque<int>d;
d.push_back(10);
d.push_back(20);
d.push_back(30);
d.push_back(40);
deque<int>d2;
d2 = d;
printDeque(d2);
if (d2.empty())
cout << "d2为空" << endl;
cout << "d2不为空 size = " << d2.size() << endl;
4）deque双端插入和删除操作
push_back(elem);//在容器尾部添加一个数据
push_front(elem);//在容器头部插入一个数据
pop_back();//删除容器最后一个数据
pop_front();//删除容器第一个数据
5）deque数据存取
at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。
operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。
front();//返回第一个数据。
back();//返回最后一个数据
6）deque插入操作
insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
7）deque删除操作
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
8）实例-sort排序
有5名选手：选手ABCDE，10个评委分别对每一名选手打分，去除最高分，去除评委中最低分，取平均分。
- 创建五名选手，放到vector中
- 遍历vector容器，取出来每一个选手，执行for循环，可以把10个评分打分存到deque容器中
- sort算法对deque容器中分数排序，pop_back pop_front去除最高和最低分
- deque容器遍历一遍，累加分数，累加分数/d.size()
- person.score = 平均分
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <vector>
#include <string>
#include <deque>
#include <algorithm>
#include <ctime>
class Player
public:
Player(string name, int score)
this->m_Name = name;
this->m_Score = score;
string m_Name; //姓名
int m_Score; //平均分
void createPlayer(vector<Player>& v)
string nameSeed = "ABCDE";
for (int i = 0; i < 5; i++)
string name = "选手";
name += nameSeed[i];
int score = 0;
Player player(name, score);
v.push_back(player);
void setScore(vector<Player>& v)
for (vector<Player>::iterator it = v.begin(); it != v.end(); it++)
deque<int>d; //存放评委打分的容器
for (int i = 0; i < 10; i++)
int score = rand() % 41 + 60; // 60 ~ 100
d.push_back(score);
cout << it->m_Name << "打分情况：" << endl;
for (deque<int>::iterator dit = d.begin(); dit != d.end();dit++)
cout << *dit << " ";
cout << endl;
sort(d.begin(), d.end());
//去除最高最低分
d.pop_back(); // 最高分
d.pop_front(); // 最低分
int sum = 0;
for (deque<int>::iterator dit = d.begin(); dit != d.end(); dit++)
sum += *dit;
//平均分
int avg = sum / d.size();
it->m_Score = avg;
void showScore(vector<Player>& v)
for (vector<Player>::iterator it = v.begin(); it != v.end(); it++)
cout << "姓名： " << (*it).m_Name << " 平均分数： " << it->m_Score << endl;
int main() {
//设置随机数种子
srand((unsigned int)time(NULL));
//1、创建5名选手
vector<Player> v;
createPlayer(v);
/*for (vector<Player>::iterator it = v.begin(); it != v.end();it++)
cout << "姓名： " << (*it).m_Name << " 分数： " << it->m_Score << endl;
}*/ //此部分为中间测试
//2、打分
setScore(v);