#include <iterator> //迭代器，包含c++11的begin() 和end()函数
#include <array> //c++11 数组类型，长度固定，提供了更好、更安全的接口，执行效率和内置数组相同，可以有效替代内置数组
#include <valarray> //c++11 值类型的数组类型，针对值类型的数组，有更多的操作，比如求和，最大最小数等。
#include <list> //双向链表,插入删除速度快,不支持随机访问
#include <forward_list> //c++11 单向链表,单向访问,插入删除速度快，不支持随机访问,没有size操作
#include <deque> //双端队列,支持快速随机访问
#include <string> //string类型,插入删除耗时
#include <vector> //迭代器类型,插入删除耗时
#include <iostream>
/*
* 具体需要哪个容器根据它的数据结构的优势来选择
* C++11后 vector<vector<int>> “>>”不用添加空格了
*/
2.迭代器不能比较大小
list<int>il = {1,2,3,4,5,6,7};
list<int>::iterator it = il.begin(), it2 = il.end();
while(it < it2) //error
{ ...}
3.begin和end
c++11新增加了auto和begin，end的结合用法。
增加了cbegin和crbegin。
#include <iterator>
#include <iostream>
#include <list>
using namespace std;
int main()
{
list<string>il = {"hello", "world", "wang", "wei", "hao" };
auto it1 = il.begin(); //list<string>::iterator
auto it2 = il.cbegin(); //list<string>::const_iterator
auto it3 = il.rbegin(); //list<string>::reverse_iterator
auto it4 = il.crbegin(); //list<string>::const_reverse_iteratror
cout << *it1 << endl;
//*it2 = "ww"; error:const类型不能修改
cout << *it2 << endl;
cout << *it3 << endl;
cout << *it4 << endl;
//*it4 = "ww"; error:const类型不能修改
} 4.容器的定义和初始化
<1.几种初始化
#include <vector>
#include <iostream>
using namespace std;
int main()
{
vector<int>ivec1; //默认初始化
vector<int>ivec2 = {1,2,3,4,5,6,7,8,9,0}; //列表初始化
//vector<int>ivec2{1,2,3,4,5,6,7,8,9,0};
vector<int>ivec3(ivec2); //拷贝初始化
//vector<int>ivec3 = ivec2;
vector<int>ivec4(ivec1.begin(), ivec1.end());//迭代器初始化
vector<int>ivec5(10); //n个元素初始化
vector<int>ivec6(10, 9); //n个元素加初始值初始化
return 0;
}<2.为了创建一个容器为另一个容器的拷贝，两个容器的类型及其元素类型必须匹配
不过当传递迭代器参数来拷贝一个范围时，就不要求容器类型是相同的。而且新容器
和原容器中的元素类型也可以不同，！只要能将拷贝的元素转换即可。
#include <iostream>
#include <vector>
#include <list>
#include <string>
#include <deque>
using namespace std;
int main()
{
list<string>il1 = {"hello", "world", "hehe"};//新标准中可以对一个容器进行列表初始化
list<string>il2(il1);
for(const string&s : il2)
cout << s << endl;
//deque<string>deq(il1);
deque<string>deq(il1.begin(), il1.end());
for(const string&s : deq)
cout << s << endl;
}只有顺序容器的构造函数才接受大小参数，关联容器并不支持
<4.标准库array具有固定大小
array类型是c++11数组类型，长度固定（必须初始的时候指定），提供了更好，更安全的接口，
执行效率和内置数组相同，可以有效替代内置数组
标准库array的大小也是类型的一部分，当定义一个array时，除了指定元素类型，还要指定容器大小。
#include <array>
array<int, 10>a = {1,2,3,4,5,6,7,8,9,0};
array<string, 10>
array<int, 10>b = a;
但是内置类型就不支持数组复制
5.赋值和swap
<1.不论第一个容器有多少元素，只要被赋值，全部为被赋值的容器的元素。
array类型不能赋值
赋值相关运算会导致指向左边的容器内部的迭代器，引用，指针失效，而swap操作将容器内容交换不会导致指向容器的迭代器，引用和指针失效
容器类型array和string除外
几种交换和赋值操作
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int>ivec;
ivec = {1,2,3,4,5,6,7,8};
for(const int &i: ivec)
cout << i << endl;
vector<int>ivec2 = {9,9,9};
ivec = ivec2; //直接赋值
for(const int &i: ivec)
cout << i << endl;
vector<int>ivec3 = {1,1,1,1,1};
vector<int>ivec4 = {2,2,2,2,2};
//swap(ivec3,ivec4); //swap的两种方式，统一使用非成语版本swap是一个好习惯
//ivec3.swap(ivec4);
for(const int &i:ivec3)
cout << i << endl;
for(const int &i:ivec4)
cout << i << endl;
ivec3.assign(10,11); //赋值assign的几种方式
//ivec3.assign({2,2,2,2,2,2});
//ivec3.assign(ivec4.begin(), ivec4.end());
for(const int &i:ivec3)
cout << i << endl;
}意味着指向容器的迭代器，引用，指针在swap操作之后都不会失效
除了array，string以外
当赋值时容器类型不匹配时
#include <string>
#include <list>
#include <vector>
#include <iostream>
using namespace std;
int main()
{
list<string>il = {"wang", "wei", "hao"};
vector<const char*>ivec = {"hao", "wei", "wang"};
il.assign(ivec.begin(), ivec.end());只能通过迭代器赋值
for(const string &s : il)
cout << s << endl;
}6.容器大小操作
size( )：返回容器中元素的个数
empty( )：查看容器是否为空，size=0时返回true
max_size( )：返回一个大于或等于该容器所能容纳最大元素数的值
forward_list不支持size( )操作。
7.关系运算符
关系运算符左右两端必须容器类型相同。
只有当其元素类型也定义了相应的比较运算符时，我们才可以使用关系运算符来比较两个容器。
8.顺序容器的操作
<1.向顺序容器里添加元素
除了array以外，所有标准库容器都能提供灵活的内存管理
例子
#include <list>
#include <string>
#include <iostream>
#include <vector>
using namespace std;
class people
{
public:
people() = default;
people(double h):height(h), sex(0), name(" "), age(0) { }
people(double h, bool s, string na, int ag):
height(h), sex(s), name(na), age(ag) { }
double height = 0.0;
bool sex = 0;
string name = "";
int age = 0;
};
int main()
{
vector<people>ivec;
people p1(188, 0, "wangweihao", 19);
ivec.push_back(p1); //c.push_back()尾部"创建"一个元素，返回void,注意创建这个词，说明它会重新建立一个元素，而不是以前的
ivec.emplace_back(171, 1, "meiyouren", 19); //C++11 c.emplace_back()同上，区别是传递的是参数，emplace传递的是参数，不是对象，就如左边
list<people>il; //一样，传递的是类的参数，emplace成员使用这些参数在容器管理的内存空间中直接构造元素。
il.push_front(p1); //c.push_front()头部创建一个元素，返回void
il.emplace_front(171, 1, "meiyouren", 19); //同上
il.emplace_front(171); //因为emplace会用参数通过容器构造对象，所以只传递了171参数，构造时调用people类的只含h的构造函数
auto iter = il.begin();
iter = il.insert(iter, p1); //c.insert(p, t) p是迭代器类型，指定位置插入t对象
il.emplace(iter, 171, 1, "haha", 20); //同上，传递的是参数
for(people &p : ivec)
{
cout << "name:" <<p.name << " sex:" << p.sex << " height:" << p.height << " age:" << p.age << endl;
}
cout << endl;
for(people &p : il)
{
cout << "name:" <<p.name << " sex:" << p.sex << " height:" << p.height << " age:" << p.age << endl;
}
vector<int>ivec2 = {1};
auto iter2 = ivec2.begin();
ivec2.insert(iter2, 3, 10); //c.insert(p, n, t) 迭代器p位置插入n个t元素
vector<int>ivec3 = {1};
auto iter3 = ivec3.begin();
ivec3.insert(iter3, ivec2.begin(), ivec2.end()); //c.insert(p, b, e) 迭代器p位置插入另一个类型相同容器迭代器（b,e）范围内的元素
vector<int>ivec4;
//ivec4.insert(ivec.begin(), {1,1,1,1,1,1,1,1}); //c.insert(p, il)迭代器p位置插入il一个花括号包围的初始值列表。但运行会报错不知是编译器的问题还是
cout << "ivec2" << endl;
for(const int &i : ivec2)
cout << i << endl;
cout << "ivec3" << endl;
for(const int &i : ivec3)
cout << i << endl;
cout << "ivec4" << endl;
for(const int &i : ivec4)
cout << i << endl;
}
运行结果：
注意：
<<1. 向一个vector,string,deque插入元素会使所有指向容器的迭代器，引用，指针失效
<<2.当我们用一个对象来初始化容器时，或将一个对象插入到容器时，实际上放的是一个拷贝，而不是对象本身。
<<3.每个insert都接受一个迭代器作为第一个参数。
<<4.insert函数将元素都插入到敌人代器所指定的位置之前
<<5.将元素插入到vector,deque,string中的任何位置都是合法的。然而这样做可能会很耗时
<<6.c++11新标准下，接受元素的个数或范围的insert版本返回指向第一个元素的迭代器。如果范围为空，不插入任何元素。
<<7.使用emplace：新标准引入了三个成员，emplace_front, emplace, emplace_back,这些操作构造而不是拷贝元素。
当我们调用emplace成员函数时，则是将参数传递给元素类型的构造函数。emplace成员使用这些参数在容器管理的内存空间中直接构造元素。
emplace_back会在容器管理的内存空间中直接创建对象，而调用push_back则会创建一个局部临时对象，并将其压入容器中。
emplace函数在容器中直接构造元素，传递给emplace函数的参数必须与元素类型的构造函数相匹配。
<2.访问元素
包括array在内的每个顺序容器都有一个front函数成员，而除forward_list之外的所有顺序容器都有一个back成员函数。这两个操作分别返回
首元素和尾元素的引用。
当然可以用迭代器c.begin( )和(c.end( ))--。但是都要确保容器非空，如果容器为空，行为是未定义的
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int>ivec = {1,2,3,4,5};
auto i = ivec.front();
auto j = ivec.back(); //forward_list不支持
i = 10; //并不修改容器的元素的值，除非一开始定义auto &i = ivec.front();
cout << i << endl;
cout << j << endl;
}顺序容器访问元素的操作例子
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int>ivec = {1,2,3,4,5,6,7,8,9,0};
//vector<int>ivec;
cout << ivec[0] << endl; //c[n] 返回下标为n的元素的引用 n>=c.size() 结果是未定义的
cout << ivec.at(0) << endl; //c.at(n) 返回下标为n的元素的引用，如果下标越界，则抛出异常out_of_range
cout << ivec.front() << endl; //c.front() 返回容器的第一个元素
cout << ivec.back() << endl; //c.back() 返回容器的最后一个元素
cout << *(ivec.begin()) << endl;
}<<1.迭代器c.end( )是末尾元素的下一个位置
<<2.为确保下标是合法的，我们可以使用at成员函数，at成员函数类似下标运算符，但如果下标越界，at会抛出一个out_of_range异常
<3.删除元素
#include <vector>
#include <list>
#include <iostream>
using namespace std;
int main()
{
int ia[] = {1,2,3,4,5,6,7,8,9,0};
vector<int>ivec;
list<int>il;
for(int i = 0; i < 10; ++i)
{
ivec.push_back(ia[i]);
il.push_back(ia[i]);
}
for(auto it = ivec.begin(); it != ivec.end();)
{
if(*it%2 == 0)
{
it = ivec.erase(it); //！坑，erase返删除元素的下一个迭代器。
}
else
it++;
}
for(auto it = il.begin(); it != il.end();)
{
if(*it%2 == 1)
{
it = il.erase(it);
}
else
it++;
}
for(const int &i : ivec)
cout << i << endl;
for(const int &i : il)
cout << i << endl;
}
c.pop_back() 删除尾元素，返回void
c.pop_front()删除首元素，返回void
c.erase(p) 删除迭代器p指向的元素，返回被删除元素的下一个元素的迭代器
c.erase(b,e) 删除迭代器(b,e)范围内的元素，返回e的下一个元素的迭代器
c.clear() 删除c中所有的元素
<<1.删除操作会改变容器的大小，所以不适合array
<<2.forward_list不支持pop_back, vector和string不支持pop_front
<<3.删除deque中除首尾位置之外的任何元素都会使所有迭代器，引用指针失效
<<4.删除前必须保证他们是存在的
<<5.注意删除返回迭代器的那些操作在循环中需要做出哪些改变！
<4.特殊的forward_list操作
forward_list其实就是数据结构的单向链表
操作如下：
#include <forward_list>
#include <string>
#include <iostream>
#include <vector>
using namespace std;
int main()
{
forward_list<int>ft = {1,2,3,4,5,6,7,8,9,0};
vector<int>ivec = {11,22,33,44};
for(const int&i : ft)
{
cout << i << " ";
}
cout << endl;
auto iter1 = ft.before_begin(); //一般返回的否是操作对象先前的迭代器
auto iter2 = ft.begin();
//auto iter = ft.cbefore_begin(); 返回一个const_iterator
cout << *iter1 << endl; //返回单向链表首元素的前一个位置迭代器，解引用未定义,随机值
cout << *iter2 << endl; //首元素
//insert
//ft.insert_after(iter2, 100); //插入到迭代器iter2指向的元素后面
//ft.insert_after(iter2, 10, 100); //10个100
//ft.insert_after(iter2, ivec.begin(), ivec.end());//插入范围,b,e不能使本对象中的范围
//ft.insert_after(iter2, {11,22,33,44,55});
for(const int&i : ft)
{
cout << i << " ";
}
cout << endl;
ft.emplace_after(iter2, 111);
for(const int&i : ft)
{
cout << i << " ";
}
cout << endl;
//erase //返回的是擦出元素的下一个元素，一定要注意
//ft.erase_after(iter2); //擦除的是迭代器所指向的后一个元素
ft.erase_after(iter1, ft.end()); //擦除的是迭代器所指向的元素的后一个元素开始
for(const int&i : ft)
{
cout << i << " ";
}
cout << endl;
return 0;
}<<1.一般要处理整个容器时，要保存两个迭代器。curr用来找元素，prev用来删元素
auto curr = ft.begin( );
auto prev = ft.before_begin( );<<2.erase_after了一定要记得修改curr。
curr = ft.erase_after(n);<<3.一定要注意函数的返回值和每次使用的迭代器指向的位置和使用函数后该迭代器应该怎样变化。
<5.改变容器大小
c.resize(n) ：调整c大小为n个元素。若n<c.size( ),则多出的元素被丢弃，若必须添加新元素，新元素使用值初始化
c.resize(n,t) ：调整c大小为n个元素。任何新添加的元素都初始值为t。
！如果缩小容器，则指向被删除元素的迭代器，引用和指针都会失效。对vector,string,deque,resize可能导致迭代器，指针引用失效。
！如果容器保存的是类类型的元素，向容器添加元素时我们必须提供初始值，或元素必须提供默认构造函数。
<6.！容器操作可能使迭代器失效
是否会使迭代器失效还要看迭代器具体使用什么数据结构实现的。
比如forward_list这个容器就比较特殊，insert( )返回的是插入元素位置的迭代器。删除erase( p )删除的是p的下一个位置的元素，返回的是删除元素下一个位置的迭代器。
因为它是由单向链表实现，指针是单向的，我们不能返回去访问先前的元素，那么删除必须指定的元素必须要保存prev先前的迭代器，不然无法实现删除。
所以每个容器具体实现的数据结构是重点。
一个例子
复制容器中元素值是奇数的，删除容器中的元素值是偶数的。
好好体会一下，这些容器的差别
#include <iostream>
#include <vector>
#include <list>
#include <forward_list>
using namespace std;
int main()
{
//vector
vector<int>ivec = {1,2,3,4,5,6,7,8,9,0};
auto iter = ivec.begin();
while(iter != ivec.end())
{
if(*iter %2 == 1)
{
iter = ivec.insert(iter, *iter);
iter += 2;
}
else
iter = ivec.erase(iter);
}
for(const int&i : ivec)
cout << i << " ";
cout << endl;
//list
list<int>il = {1,2,3,4,5,6,7,8,9,0};
auto iter2 = il.begin();
while(iter2 != il.end())
{
if(*iter2%2 == 1)
{
il.insert(iter2, *iter2);
iter2++;
}
else
{
iter2 = il.erase(iter2);
}
}
for(const int&i : il)
cout << i << " ";
cout << endl;
//forward_list
forward_list<int>ft = {1,2,3,4,5,6,7,8,9,0};
auto fter1 = ft.before_begin();
auto fter2 = ft.begin();
while(fter2 != ft.end())
{
if(*fter2%2 == 1)
{
fter1 = fter2;
fter2 = ft.insert_after(fter2, *fter2);
fter1++;
fter2++;
}
else
{
fter2 = ft.erase_after(fter1);
}
}
for(const int&i : ft)
cout << i << " ";
cout << endl;
}在看个例子
给容器中每个元素后面插入值
#include <vector>
#include <iostream>
using namespace std;
int main()
{
vector<int>ivec = {1,2,3,4,5,6,7,8,9,0};
auto iter = ivec.begin();
while(iter != ivec.end())
{
iter++; //前插
iter = ivec.insert(iter, 1);//插入后迭代器失效,如果不赋值给iter，iter失效。
iter++;
}
for(const int&i : ivec)
cout << i << " ";
cout << endl;
}迭代器失效了我们却没有保存iter。
！注意：
<<1.对于insert来说，除了forward_list插入是后插外，其他容器是前插，前插返回前插的元素的迭代器，记得保存，插入后迭代器会失效。后插返回的是后插元素的迭代器。
总之不管插入位置，只要插入返回的就是插入的元素的迭代器，但是要考虑它的位置是前插还是后插。
<<2.管理迭代器，确认每次改变容器的操作之后都正确的重新定位迭代器。这个对vector,string,deque尤其重要。
<<3.记不起来时想下它的数据结构。
<7.vector对象是如何增长的
#include <iostream>
#include <vector>
using namespace std;
#define CAP(x) cout << "capicity = " << x.capacity() << endl; //capacity()返回容器的容量
#define SIZ(x) cout << "size = " << x.size() << endl; //size()返回容器内部元素的多少
int main()
{
vector<int>ivec;
CAP(ivec);
SIZ(ivec);
ivec.reserve(10); //分配至少能容纳n个元素的空间，小于当前容量什么也不做
CAP(ivec);
SIZ(ivec);
ivec.shrink_to_fit(); //缩减容量capacity到size()的大小
CAP(ivec);
SIZ(ivec);
vector<int>ivec2(10,10);
CAP(ivec2);
SIZ(ivec2);
ivec2.reserve(20);
CAP(ivec2);
SIZ(ivec2);
ivec2.resize(9); //设置元素的大小，影响size(),多余的默认使用值初始化。
CAP(ivec2);
SIZ(ivec2);
}resize( )设定size( )
reserve( )设定capacity( )
8.额外的string操作
<1.构造string的其他方法
#include <iostream>
#include <string>
using namespace std;
int main()
{
//s若拷贝字符数组必须有空字符结尾
//注意越界问题
char a[100] = "abcdefghijklmnopqrstuvwxyz";
string s(a, 10); //string s(cp, n) s是cp指向的数组中的前n个字符的拷贝，此数组至少应该包含n个字符
cout << s << endl;
string s2 = "wangweihao";
string s3(s2, 5); //string s(s1, pos) s是s1字符串从pos后面开始的字符串,如果n>s1.size()结果未定义
cout << s3 << endl;
string s4(s2, 5, 2); //string s(s1, pos, len) s是s1从pos位置后面的长度为len的字符串
string s5(a+5, 2); //这种方式a必须是字符数组，不能是string类型
cout << s4 << endl;
cout << s5 << endl;
//substr操作返回一个string, 它是原始string的一部分或者全部的拷贝,可以传递开始和结尾
string ss = "hello,world";
string ss2;
ss2 = ss.substr(0,5); //复制下标0-4
//ss2 = ss.substr(5); //复制下标5到结束
cout << ss2 << endl;
ss2 = ss.substr(12); //越界，发出out_of_range异常
return 0;
}<2.改变string的其他方法
<<1.
#include <string>
#include <iostream>
using namespace std;
int main()
{
string s = "hello,world!";
//string除了assign和insert,erase操作，还定义了自己的insert和erase版本
s.insert(s.size(), 5, '!'); //末尾插入5个感叹号
cout << s << endl;
s.erase(s.size()-5, 5); //删除最后的5个字符
cout << s << endl;
//标准库string还定义了接受c风格字符数组的insert和assign版本
string s1;
const char *p = "hello, world!";
s1.assign(p, 7); //复制p的前7个字符
cout << s1 << endl;
//s1.insert(s.size(), p+4); //error: out_of_range
//cout << s1 << endl;
string s2 = "hello", s3 = "world";
s2.insert(0, s3); //将s3插入到s2的0起始位置
cout << s2 << endl;
s2.insert(0, s3, 0, s3.size()-1); //从s2 的0处插入s3的(0, s3.size()-1)范围的元素
cout << s2 << endl;
}#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("c++ primer");
s.append(" 5th Ed."); //在末尾追加字符串
//s.insert(s.size(), " 5th Ed."); 和上面等价
cout << s << endl;
//replace操作是调用erase和insert的一种简写方式
//s.replace(11, 3, "4th");
s.erase(11, 3);
s.insert(11, "4th");
cout << s << endl;
}！<<3.string搜索操作
string的搜索操作
s.find(args) 查找args第一次出现的位置
s.rfind(args) 查找args最后一次出现的位置
s.find_first_of(args) 在s中查找args任何一个字符第一次出现的位置
s.find_last_of(args) 在s中查找args任何一个字符最后一次出现的位置
s.find_first_not_of(args) 在s中查找第一个不在args中的字符
s.find_last_not_of(args) 在s中查找最后一个不再args中的字符
args的形式
c,pos pos位置开始查找字符c,pos默认为0
s2,pos pos位置开始查找字符串s2,pos默认为0
cp,pos pos位置开始查找指针cp指向的以空字符结尾的C风格字符串,pos默认为0
cp,pos,n pos位置开始查找指针cp指向的数组的前n个字符。pos和n无默认值
例子1：
#include <iostream>
#include <string>
using namespace std;
int main()
{
//find,区分大小写
//搜索成功返回一个string::size_type值，若失败,返回一个string::npos的static成员(unsigned)
string s("wangweihao");
auto pos1 = s.find("wei"); //pos返回的是第一次出现的下标,若找不到则返回一个最大数
cout << pos1 << endl;
string s1("0123456789");
string name("0rrr1r");
//查找给定字符串中任何一个字符匹配的位置。
auto pos2 = name.find_first_of(s1); //s1在name中出现的第一个数字在name中的下标
cout << pos2 << endl;
//搜索第一个不在参数中的字符
auto pos3 = s1.find_first_not_of(name); //s1第一不在name中出现的是0
cout << pos3 << endl;
}一般的find都是从左到右，rfind提供了从右到左。
find例子2：
找出小写字母和数字区分开。
字母用了—代替，数字用了|代替
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s("abc2fe32f2ds2");
string s1("abcdefghijklmnopqrstuvwxyz"); //要去掉字符，那么首先要创建s1，s中的字符可以和s1匹配，然后替换
string s2("1234567890"); //同理去掉数字
string::size_type pos = 0; //起始位置初始化为0
while((pos = s.find_first_of(s1, pos)) != string::npos) //找到位置返回，如果没找到返回string::npos
{
s.replace(pos, 1, "-");
pos++;
}
cout << s << endl;
pos = 0; //记得再次初始化，否则没有作用
while((pos = s.find_first_of(s2, pos)) != string::npos)
{
s.replace(pos, 1, "|");
pos++;
}
cout << s << endl;
}
注意：当从文件中读取字母时，若有空格，用getline读取一行。
例子3：也是重要的一个
从一篇英语文章中找出除了包含有字母出头bf或字母下出头pqg这种的单词外最长的一个单词。
#include <iostream>
#include <string>
#include <fstream> //文件流
#include <vector>
#include <sstream>
using namespace std;
int main(int argc, char *argv[])
{
vector<string>cps; //存储文章
string sent;
string word;
string Maxlenword;
ifstream is(argv[1]); //创建文件流并且读取
string s1("bdfgpq"); //这是要除去的单词所包含的
while(getline(is, sent)) //一次读取一行，因为如果是字符串流读取的话，遇到空格就会停止。
{
cps.push_back(sent);
}
for(auto it = cps.begin(); it != cps.end(); ++it) //处理文章，一次一个string
{
cout << "\n\n\n" << endl;
cout << "处理" << *it << endl;
istringstream ist(*it); //string绑定到istringstream流上，因为一次要处理一个单词
while(!ist.eof())
{
ist >> word;
cout << "word: " << word << endl;
auto pos = word.find_first_of(s1); //验证单词
if(pos == string::npos) //如果验证成功不包含s1,处理
{
if(word.size() > Maxlenword.size()) //比MAX大就存到MAX里面
{
Maxlenword = word;
cout << "temp MaxlenWord:" << Maxlenword << endl;
}
}
pos = 0; //记得pos的位置一定要恢复到起始
}
}
cout << "MaxLengWord is " << Maxlenword << endl; //输出最大的
}<<4.compare函数,compare函数和c函数的strcmp函数很相似
等于大于小于返回0，正数或者负数
compare的6个版本如下
#include <iostream>
#include <string>
using namespace std;
int main()
{
string s1 = "aaacaaaaa";
string s2 = "aaaaaaaab";
char *p = "aaaaaaaac";
cout << s1.compare(s2) << endl; //s1>s2
cout << s1.compare(5, 3, s2) << endl; //s1从第五个字符开始的3个字符小于s2
cout << s1.compare(0, 5, s2, 0, 5) << endl; //从s1的0开始的5个字符和s2从0开始的5个字符比较
cout << s1.compare(p) << endl; //比较p指向的地址开始的字符串
cout << s1.compare(5, 4, p) << endl; //比较s1从第5个开始的4个字符和p指向的地址的字符串
cout << s1.compare(5, 4, p, 4) << endl; //比较s1从第5个开始的4个字符和p指向的地址的4个字符
}<<5.数值转换
新标准引入了多个函数，可以实现数值数据与标准库string之间的转换
int main()
{
int a = 100;
string s;
s = to_string(a);
cout << s << endl;
std::size_t m = 2;
string s1 = "1000";
int i = stoi(s1); //stoi
long b = stol(s1);//stol
unsigned long c = stoul(s1);//stoul
long long d = stoll(s1);//stoll
unsigned long long e = stoull(s1);//stoull
cout << "int:" << i << "long:" << b << "unsigned long:" << c << "longlong:" << d << "unsigned longlong:" << e << endl;
string s2 = "1000.11";
float f = stof(s2);//stof
double g = stod(s2);//stod
long double h = stold(s2);//stold
cout << "float:" << f << "double:" << g << "long double:" << h << endl;
}设计一个类，它有三个unsigned成员，分别表示年，月和日。为其编写构造函数，接受一个表示日期的string参数，你的构造函数应该能处理不同数据格式，
如Jan 1， 1900 1/1/1990 Jan 1 1900形式
记录一下9.51的题，没有处理January 1，1900形式，月份统一用Jan三个字母表示了，如果完全按题就是比较这个字符串的指定书目前几个字母就好。
#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <map>
using namespace std;
class dat
{
public:
dat() = default;
dat(unsigned d, unsigned y, unsigned m):
day(d), year(y), mouth(m) { };
dat(string &s);
void print(void) { cout << year << "." << mouth << "." << day << endl; }
private:
string s1 = "0123456789";
unsigned long day;
unsigned long year;
unsigned long mouth;
};
dat::dat(string &s)
{
vector<string>ivecs;//存储年月日
string s1;//temp
string::size_type pos;
string des(",/");
while((pos = s.find_first_of(des)) != string::npos)
{
s.replace(pos, 1, " ");
pos++;
}
//cout << s << endl;
istringstream is(s);
while(!is.eof())
{
is >> s1;
ivecs.push_back(s1);
}
map<string, unsigned>mp;
mp.insert(pair<string, unsigned long>("Jan", 1));
mp.insert(pair<string, unsigned long>("Feb", 2));
mp.insert(pair<string, unsigned long>("Apr", 4));
mp.insert(pair<string, unsigned long>("May", 5));
mp.insert(pair<string, unsigned long>("Jun", 6));
mp.insert(pair<string, unsigned long>("Jul", 7));
mp.insert(pair<string, unsigned long>("Aug", 8));
mp.insert(pair<string, unsigned long>("Sep", 9));
mp.insert(pair<string, unsigned long>("Oct", 10));
mp.insert(pair<string, unsigned long>("Nov", 11));
mp.insert(pair<string, unsigned long>("Dec", 12));
//分别处理3个字符串，转化为年月日
if(ivecs[0][0] <= 57 && ivecs[0][0] >= 48)
mouth = stoul(ivecs[0]);
else
{
auto it = mp.find(ivecs[0]);
mouth = (*it).second;
}
day = stoul(ivecs[1]);
year = stoul(ivecs[2]);
}
int main()
{
string s;
s = "Jan 1, 1900";
dat date(s);
date.print();
string s2;
s2 = "1/1/1990";
dat date2(s2);
date2.print();
string s3;
s3 = "Jan 1 1900";
dat date3(s3);
date3.print();
}
<9.容器适配器
container_type是实现适配器的底层容器类型
三种：stack, queue, priority_queue
本质上：适配器是一种机制，能使某种事物的行为看起来像另外一种事物一样
一个容器适配器接受一种已有的容器类型，使其行为看起来像一种不同的类型
理解：容器适配器是基于已有的容器做的功能上的一种改进。
定义一个适配器：
每个适配器都有两个默认构造函数：默认构造函数创建一个空对象，接受一个容器的构造函数拷贝该容器来初始化适配器。
stack<int> stk(deq); //用一个deque类型的容器来初始化stack适配器
我们可以创建一个适配器时将一个命名的顺序容器作为第二个类型参数，来重载默认容器
stack<string, vector<string>> str_stk;
stack<string, vector<string>> str_stk2(ivecs);
<1.stack
stack：一种元素先进后出的一种容器
stack可以使用除了array和forward_list类型的其他任何类型的容器来构造
#include <iostream>
#include <string>
#include <stack>
#include <vector>
#include <deque>
using namespace std;
int main()
{
vector<int>ivec = {1,2,3,4,5,6,7,8,9,0};
deque<int>deq = {1,2,3,4,5,6,7,8,9,0};
//stack<int>stk(ivec); error:因为stack本来是使用deque改进的一种适配器，
//如果要用vector构造,必须像下面明确指定stack<int, vector<int>>.
stack<int>stk(deq);
stack<int, vector<int>>stk2(ivec);//明确指出stack在vector上面实现。
int val;
while(!stk.empty())
{
cout << stk.top() << endl;
stk.pop();
}
while(!stk2.empty())
{
cout << stk2.top() << endl;
stk2.pop();
}
}
//stack默认是deque实现，也可以在list或vector实现
//s.pop() 删除栈顶元素，但不返回元素值
//s.push(item) 创建一个新元素压入栈顶
//s.emplace(args) 同前面所说args是参数，动态构造一个对象
//s.top() 返回栈顶元素，但不将元素出栈
<2.queue
queue：一种元素先进先出的容器
queue可以由list和deque来构造，但是不能由vector来构造，默认是deque构造
#include <queue>
#include <vector>
#include <list>
#include <deque>
#include <iostream>
using namespace std;
int main()
{
list<int>il = {1,2,3,4,5,6,7,8,9,0};
deque<int>deq = {1,2,3,4,5,6,7,8,9,0};
vector<int>ivec = {1,2,3,4,5,6,7,8,9,0};
//queue<int>que(il); error:queue默认是deque构造的，只能由deque来初始化
queue<int>que(deq);//yes
//当然可以显示指定由那个来构造
queue<int, list<int>>que2(il);//yes
//但是不能是vector<>
//- -但是！ 我用vector成功了
//原因是vector可以支持front这个操作，但是把que.front换成que.pop()就会报一堆错
//其他的list和deque说是可以使用应该是可以兼容全部的操作。so 动手实践很重要
queue<int, vector<int>>que3(ivec);
//while(!que.empty())
{
cout << que.front() << endl;
que.pop();
}
cout << que.back() << endl;
}
queue和priority_queue都在queue头文件中
priority_queue就是一种带优先级的队列，不如10个元素，它首元素是最大或最小。
操作
//q.pop()返回queue的首元素或priority_queue的最高优先级元素，不删除元素
//q.front()返回首元素或尾元素，不删除
//q.back()
//q.top()返回最高优先级的元素，不删除，只适用于priority_queue
//q.push(item)在queue末尾或priority_queue中恰当位置创建一个元素
//q.emplace(args)动态构造对象