常用STL库的整理

1、vector

1. 在C++中的详细说明vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。2. 使用vector，必须在你的头文件中包含下面的代码：  #include vector属于std命名域的，因此需要通过命名限定，如下完成你的代码：　　using std::vector;　　vector vInts;　　或者连在一起，使用全名：      std::vector vInts;　　建议使用全局的命名域方式：    using namespace std;3. 初始化   vector                 // 创建一个空的vector。vector c1(c2)          // 复制一个vectorvector c(n)            // 创建一个vector，含有n个数据，数据均已缺省构造产生vector c(n, elem)      // 创建一个含有n个elem拷贝的vectorvector c(beg,end)      // 创建一个含有n个elem拷贝的vector4. 析构函数c.~vector ()           // 销毁所有数据，释放内存5. 成员函数c.assign(beg,end)c.assign(n,elem)　　将[beg; end)区间中的数据赋值给c。将n个elem的拷贝赋值给c。c.at(idx)　　传回索引idx所指的数据，如果idx越界，抛出out_of_range。c.back()      // 传回最后一个数据，不检查这个数据是否存在。c.begin()     // 传回迭代器中的第一个数据地址。c.capacity()  // 返回容器中数据个数。c.clear()     // 移除容器中所有数据。c.empty()     // 判断容器是否为空。c.end()       // 指向迭代器中末端元素的下一个，指向一个不存在元素。c.erase(pos)  // 删除pos位置的数据，传回下一个数据的位置。c.erase(beg,end)  //删除[beg,end)区间的数据，传回下一个数据的位置。c.front()     // 传回第一个数据。get_allocator // 使用构造函数返回一个拷贝。c.insert(pos,elem)    // 在pos位置插入一个elem拷贝，传回新数据位置。c.insert(pos,n,elem)  // 在pos位置插入n个elem数据。无返回值。c.insert(pos,beg,end) // 在pos位置插入在[beg,end)区间的数据。无返回值。　　c.max_size()       // 返回容器中最大数据的数量。c.pop_back()       // 删除最后一个数据。c.push_back(elem)  // 在尾部加入一个数据。c.rbegin()         // 传回一个逆向队列的第一个数据。c.rend()           // 传回一个逆向队列的最后一个数据的下一个位置。c.resize(num)      // 重新指定队列的长度。c.reserve()        // 保留适当的容量。c.size()           // 返回容器中实际数据的个数。c1.swap(c2)swap(c1,c2)        // 将c1和c2元素互换。同上操作。operator[]         // 返回容器中指定位置的一个引用。6. 用法示例：6.1. 创建一个vectorvector容器提供了多种创建方法，下面介绍几种常用的。创建一个Widget类型的空的vector对象：　　vector vWidgets;　　创建一个包含500个Widget类型数据的vector：　　vector vWidgets(500);　　创建一个包含500个Widget类型数据的vector，并且都初始化为0：　　vector vWidgets(500, Widget(0));　　创建一个Widget的拷贝：　　vector vWidgetsFromAnother(vWidgets);　　向vector添加一个数据　　vector添加数据的缺省方法是push_back()。    push_back()函数表示将数据添加到vector的尾部，并按需要来分配内存。例如：向vector中添加10个数据，需要如下编写代码：　　for(int i= 0;i<10; i++) {　　  vWidgets.push_back(Widget(i));　　}6.2 获取vector中指定位置的数据　　vector里面的数据是动态分配的，使用push_back()的一系列分配空间常常决定于文件或一些数据源。    如果想知道vector存放了多少数据，可以使用empty()。    获取vector的大小，可以使用size()。例如，如果想获取一个vector v的大小，但不知道它是否为空，或者已经包含了数据，如果为空想设置为-1，你可以使用下面的代码实现：　　int nSize = v.empty() ? -1 : static_cast(v.size());　　6.3 访问vector中的数据使用两种方法来访问vector。1、 vector::at()2、 vector::operator[]　　operator[]主要是为了与C语言进行兼容。它可以像C语言数组一样操作。    但at()是我们的首选，因为at()进行了边界检查，如果访问超过了vector的范围，将抛出一个例外。    由于operator[]容易造成一些错误，所有我们很少用它，下面进行验证一下：　　分析下面的代码：　　vector v;　　v.reserve(10);　　    for(int i=0; i<7; i++) {　　  v.push_back(i);　　}　　    try {int iVal1 = v[7];　　  // not bounds checked - will not throw　　  int iVal2 = v.at(7);　　  // bounds checked - will throw if out of range　　}     catch(const exception& e) {　　  cout << e.what();　　}　　6.3 删除vector中的数据vector能够非常容易地添加数据，也能很方便地取出数据，同样vector提供了erase()，pop_back()，clear()来删除数据，当删除数据时，应该知道要删除尾部的数据，或者是删除所有数据，还是个别的数据。Remove_if()算法 如果要使用remove_if()，需要在头文件中包含如下代码：：　　#include Remove_if()有三个参数：　　1、 iterator _First：指向第一个数据的迭代指针。　　2、 iterator _Last：指向最后一个数据的迭代指针。　　3、 predicate _Pred：一个可以对迭代操作的条件函数。　　6.4 条件函数条件函数是一个按照用户定义的条件返回是或否的结果，是最基本的函数指针，或是一个函数对象。这个函数对象需要支持所有的函数调用操作，重载operator()()操作。remove_if()是通过unary_function继承下来的，允许传递数据作为条件。例如，假如想从一个vector中删除匹配的数据，如果字串中包含了一个值，从这个值开始，从这个值结束。首先应该建立一个数据结构来包含这些数据，类似代码如下：#include enum findmodes {  FM_INVALID = 0,  FM_IS,　FM_STARTSWITH,　FM_ENDSWITH,　FM_CONTAINS};typedef struct tagFindStr {　UINT iMode;　CString szMatchStr;} FindStr;typedef FindStr* LPFINDSTR;　　然后处理条件判断：class FindMatchingString : public std::unary_function {public:　FindMatchingString(const LPFINDSTR lpFS) :　m_lpFS(lpFS) {}　bool operator()(CString& szStringToCompare) const {　　bool retVal = false;　　    switch (m_lpFS->iMode) {　　case FM_IS: {　　  retVal = (szStringToCompare == m_lpFDD->szMatchStr);　　  break;　　}　　case FM_STARTSWITH: {　　  retVal = (szStringToCompare.Left(m_lpFDD->szMatchStr.GetLength())　　    == m_lpFDD->szWindowTitle);　　  break;　　}　　case FM_ENDSWITH: {　　  retVal = (szStringToCompare.Right(m_lpFDD->szMatchStr.GetLength())　　    == m_lpFDD->szMatchStr);　　break;　　}　　case FM_CONTAINS: {　　  retVal = (szStringToCompare.Find(m_lpFDD->szMatchStr) != -1);　　  break;　　}　  }　  return retVal;  }private:　LPFINDSTR m_lpFS;};通过这个操作你可以从vector中有效地删除数据：    FindStr fs;　　fs.iMode = FM_CONTAINS;　　fs.szMatchStr = szRemove;　　vs.erase(std::remove_if(vs.begin(), vs.end(), FindMatchingString(&fs)), vs.end());　　Remove(),remove_if()等所有的移出操作都是建立在一个迭代范围上的，不能操作容器中的数据。所以在使用remove_if()，实际上操作的时容器里数据的上面的。看到remove_if()实际上是根据条件对迭代地址进行了修改，在数据的后面存在一些残余的数据，那些需要删除的数据。剩下的数据的位置可能不是原来的数据，但他们是不知道的。调用erase()来删除那些残余的数据。注意上面例子中通过erase()删除remove_if()的结果和vs.enc()范围的数据。7. 综合例子：//---------------------------------------------------------------------------#include #pragma hdrstop#include "Unit1.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;#include #include using namespace std;struct STResult{    double Time;    double Xp;    double Yp;    int id;};//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner)    : TForm(Owner){}vector ResultVector;void __fastcall test(){    //test    //vector ResultVector;    STResult stritem;    stritem.Time = .1;    stritem.Xp = .1;    stritem.Yp = .1;    stritem.id = 1;    ResultVector.push_back( stritem );}//---------------------------------------------------------------------------void __fastcall TForm1::Button1Click(TObject *Sender){    test();    assert(ResultVector[0].id == 1);}//---------------------------------------------------------------------------

2、string

#include <string>// 注意是<string>，不是<string.h>，带.h的是C语言中的头文件using  std::string;using  std::wstring;或using namespace std;下面你就可以使用string/wstring了，它们两分别对应着char和wchar_t。string和wstring的用法是一样的，以下只用string作介绍：string类的构造函数：string(const char *s);    //用c字符串s初始化string(int n,char c);     //用n个字符c初始化此外，string类还支持默认构造函数和复制构造函数，如string s1；string s2="hello"；都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常 ；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函数提供范围检查，当越界时会抛出out_of_range异常，下标运算符[]不提供检查访问。const char *data()const;//返回一个非null终止的c字符数组const char *c_str()const;//返回一个以null终止的c字符串int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中，返回实际拷贝的数目string的特性描述:int capacity()const;    //返回当前容量（即string中不必增加内存即可存放的元素个数）int max_size()const;    //返回string对象中可存放的最大字符串的长度int size()const;        //返回当前字符串的大小int length()const;       //返回当前字符串的长度bool empty()const;        //当前字符串是否为空void resize(int len,char c);//把字符串当前大小置为len，并用字符c填充不足的部分string类的输入输出操作:string类重载运算符operator>>用于输入，同样重载运算符operator<<用于输出操作。函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中，以换行符'\n'分开。string的赋值：string &operator=(const string &s);//把字符串s赋给当前字符串string &assign(const char *s);//用c类型字符串s赋值string &assign(const char *s,int n);//用c字符串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个字符赋给当前字符串string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串string的连接：string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾 string &append(const char *s);            //把c类型字符串s连接到当前字符串结尾string &append(const char *s,int n);//把c类型字符串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个字符cstring &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾string的比较：bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等运算符">","<",">=","<=","!="均被重载用于字符串的比较；int compare(const string &s) const;//比较当前字符串和s的大小int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//pos2开始的n2个字符组成的字符串的大小int compare(const char *s) const;int compare(int pos, int n,const char *s) const;int compare(int pos, int n,const char *s, int pos2) const;compare函数在>时返回1，<时返回-1，==时返回0  string的子串：string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串string的交换：void swap(string &s2);    //交换当前字符串与s2的值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 char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置//查找成功时返回所在位置，失败返回string::npos的值 int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置int rfind(const char *s, int pos = npos) const;int rfind(const char *s, int pos, int n = npos) const;int rfind(const string &s,int pos = npos) const;//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置，成功返回所在位置，失败时返回string::npos的值 int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置int find_first_of(const char *s, int pos = 0) const;int find_first_of(const char *s, int pos, int n) const;int find_first_of(const string &s,int pos = 0) const;//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos int find_first_not_of(char c, int pos = 0) const;int find_first_not_of(const char *s, int pos = 0) const;int find_first_not_of(const char *s, int pos,int n) const;int find_first_not_of(const string &s,int pos = 0) const;//从当前串中查找第一个不在串s中的字符出现的位置，失败返回string::npos int find_last_of(char c, int pos = npos) const;int find_last_of(const char *s, int pos = npos) const;int find_last_of(const char *s, int pos, int n = npos) const;int find_last_of(const string &s,int pos = npos) const; int find_last_not_of(char c, int pos = npos) const;int find_last_not_of(const char *s, int pos = npos) const;int find_last_not_of(const char *s, int pos, int n) const;int find_last_not_of(const string &s,int pos = npos) const;//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似，只不过是从后向前查找//string类的替换函数： string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符，然后在p0处插入串sstring &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符，然后在p0处插入字符串s的前n个字符string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符，然后在p0处插入串sstring &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符，然后在p0处插入串s中从pos开始的n个字符string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符，然后在p0处插入n个字符cstring &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之间的部分替换为字符串sstring &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之间的部分替换为s的前n个字符string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之间的部分替换为串sstring &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之间的部分替换为n个字符cstring &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之间的部分替换成[first，last）之间的字符串string类的插入函数： string &insert(int p0, const char *s);string &insert(int p0, const char *s, int n);string &insert(int p0,const string &s);string &insert(int p0,const string &s, int pos, int n);//前4个函数在p0位置插入字符串s中pos开始的前n个字符string &insert(int p0, int n, char c);//此函数在p0处插入n个字符citerator insert(iterator it, char c);//在it处插入字符c，返回插入后迭代器的位置void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first，last）之间的字符void insert(iterator it, int n, char c);//在it处插入n个字符cstring类的删除函数 iterator erase(iterator first, iterator last);//删除[first，last）之间的所有字符，返回删除后迭代器的位置iterator erase(iterator it);//删除it指向的字符，返回删除后迭代器的位置string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符，返回修改后的字符串string类的迭代器处理： string类提供了向前和向后遍历的迭代器iterator，迭代器提供了访问各个字符的语法，类似于指针操作，迭代器不检查范围。用string::iterator或string::const_iterator声明迭代器变量，const_iterator不允许改变迭代的内容。常用迭代器函数有：const_iterator begin()const;iterator begin();                //返回string的起始位置const_iterator end()const;iterator end();                    //返回string的最后一个字符后面的位置const_iterator rbegin()const;iterator rbegin();                //返回string的最后一个字符的位置const_iterator rend()const;iterator rend();                    //返回string第一个字符位置的前面rbegin和rend用于从后向前的迭代访问，通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现字符串流处理： 通过定义ostringstream和istringstream变量实现，#include <sstream>头文件中例如：    string input("hello,this is a test");    istringstream is(input);    string s1,s2,s3,s4;    is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test"    ostringstream os;    os<<s1<<s2<<s3<<s4;    cout<<os.str();

3、sstream

1、头文件[cpp] view plaincopyprint?#include <sstream>  2、作用istringstream类用于执行C++风格的字符串流的输入操作。 ostringstream类用于执行C++风格的字符串流的输出操作。 strstream类同时可以支持C++风格的串流的输入输出操作。3、具体分析istringstream类描述：从流中提取数据，支持 >> 操作这里字符串可以包括多个单词，单词之间使用空格分开istringstream的构造函数原形：  istringstream::istringstream(string str);  初始化：使用字符串进行初始化istringstream istr("1 56.7");  istr.str("1 56.7");//把字符串"1 56.7"存入字符串流中   使用：我们可以使用分解点获取不同的数据，完成 字符串 到 其他类型 的转换常用成员函数：str()：使istringstream对象返回一个string字符串  举例：把字符串类型的数据转换为其他类型#include <iostream>   #include <sstream>   using namespace std;  int main()  {      istringstream istr("1 56.7");      cout<<istr.str()<<endl;//直接输出字符串的数据 "1 56.7"       string str = istr.str();//函数str()返回一个字符串       cout<<str<<endl;      int n;      double d;      //以空格为界，把istringstream中数据取出，应进行类型转换       istr>>n;//第一个数为整型数据，输出1       istr>>d;//第二个数位浮点数，输出56.7       //假设换下存储类型       istr>>d;//istringstream第一个数要自动变成浮点型，输出仍为1       istr>>n;//istringstream第二个数要自动变成整型，有数字的阶段，输出为56       //测试输出       cout<<d<<endl;      cout<<n<<endl;      system("pause");      return 1;  }  举例2：把一行字符串放入流中，单词以空格隔开。之后把一个个单词从流中依次读取到字符串#include <iostream>   #include <sstream>   using namespace std;  int main()  {      istringstream istr;      string line,str;      while (getline(cin,line))//从终端接收一行字符串，并放入字符串line中       {          istr.str(line);//把line中的字符串存入字符串流中           while(istr >> str)//每次读取一个单词（以空格为界），存入str中           {              cout<<str<<endl;          }      }      system("pause");      return 1;  }  输入：123 34 45输出：123  换行 34 换行 45ostringstream类描述：把其他类型的数据写入流(往流中写入数据)，支持<<操作ostringstream的构造函数原形：  ostringstream::ostringstream(string str);  初始化：使用字符串进行初始化ostringstream ostr("1234");  ostr.str("1234");//把字符串"1234"存入字符串流中  举例：#include <iostream>   #include <sstream>   using namespace std;  int main()  {      //初始化输出字符串流ostr       ostringstream ostr("1234");      cout<<ostr.str()<<endl;//输出1234       ostr.put('5');//字符5顶替了1的位置       cout<<ostr.str()<<endl;//输出5234       ostr<<"67";//字符串67替代了23的位置，输出5674       string str = ostr.str();      cout<<str<<endl;      system("pause");      return 1;  }  stringstream类描述：是对istringstream和ostringstream类的综合，支持<<, >>操作符，可以进行字符串到其它类型的快速转换stringstream的构造函数原形如下：  stringstream::stringstream(string str);  初始化：使用字符串进行初始化stringstream str("1234");  str.str("1234");//把字符串"1234"存入字符串流中  作用：1、stringstream通常是用来做数据转换的2、将文件的所有数据一次性读入内存举例1：基本数据类型变字符串/*基本数据类型变字符串*/  #include <fstream>   #include <iostream>   #include <sstream>   using namespace std;  int main()  {      /*整型变字符串*/      int n = 10;      string str;      stringstream stream;      stream << n;      stream >> str;      cout<<str<<endl;      stream.clear();//多次使用stringstream，要先清空下，不能使用stream.str("");否则下面输出10       /*char* 变 string*/      char cStr[10] = "china";      stream << cStr;      stream >> str;      cout<<str<<endl;      system("pause");      return 1;  }  }举例2：字符串变基本数据类型/*字符串变基本数据类型*/  #include <fstream>   #include <iostream>   #include <sstream>   using namespace std;  int main()  {      /*字符串 变 double*/      double n;      string str = "12.5";      stringstream stream;      stream << str;      stream >> n;      cout<<n<<endl;      stream.clear();//多次使用stringstream，要先清空下,不能使用stream.str("");       /*string 变 char* */      string str1 = "china";      char cStr[10];      stream << str1;      stream >> cStr;      cout<<cStr<<endl;//输出china       system("pause");      return 1;  }   注意：#include <iostream>   #include <sstream>   using namespace std;  int main(int argc,char *argv[])  {      std::stringstream stream;      string str;      while(1)      {             //clear()，这个名字让很多人想当然地认为它会清除流的内容。           //实际上，它并不清空任何内容，它只是重置了流的状态标志而已！           stream.clear();            // 去掉下面这行注释，清空stringstream的缓冲，每次循环内存消耗将不再增加!           //stream.str("");                 stream<<"sdfsdfdsfsadfsdafsdfsdgsdgsdgsadgdsgsdagasdgsdagsadgsdgsgdsagsadgs";          stream>>str;             //测试输出每次循环，你的内存消耗增加了多少！           cout<<"Size of stream = "<<stream.str().length()<<endl;          system("PAUSE");      }      system("PAUSE");      return EXIT_SUCCESS;  }  

4、set

1.   常用函数1)        构造函数和析构函数set c:创建空集合,不包含任何元素set c(op):以op为排序准则，产生一个空的setset c1(c2):复制c2中的元素到c1中set c(const value_type *first, const value_type* last):复制[first, last)之间元素构成新集合set c(const value_type *first, const value_type* last,op):以op为排序准则，复制[first, last)之间元素构成新集合。c.~set()销毁所有元素，释放内存multiset mc:创建空集合,不包含任何元素multiset mc(op):以op为排序准则，产生一个空的setmultiset c1(c2):复制c2中的元素到c1中multiset c(const value_type *first, const value_type* last):复制[first, last)之间元素构成新集合multiset c(const value_type *first, const value_type* last,op):以op为排序准则，复制[first, last)之间元素构成新集合。c.~set()销毁所有元素，释放内存[cpp] view plaincopy// constructing sets  #include <iostream>  #include <set>  bool fncomp (int lhs, int rhs) {return lhs<rhs;}  struct classcomp {    bool operator() (const int& lhs, const int& rhs) const    {return lhs<rhs;}  };  int main ()  {    std::set<int> first;                           // empty set of ints    int myints[]= {10,20,30,40,50};    std::set<int> second (myints,myints+5);        // range    std::set<int> third (second);                  // a copy of second    std::set<int> fourth (second.begin(), second.end());  // iterator ctor.    std::set<int,classcomp> fifth;                 // class as Compare    bool(*fn_pt)(int,int) = fncomp;    std::set<int,bool(*)(int,int)> sixth (fn_pt);  // function pointer as Compare    return 0;  }  2)        大小、判断空函数    int size() const:返回容器元素个数    bool empty() const:判断容器是否为空，若返回true，表明容器已空3)        增加、删除函数      pair<iterator,bool> insert( x):插入元素x    iterator insert(iterator it,x):在迭代器it处插入元素x    void insert(const value_type *first,const value_type *last):插入[first, last)之间元素    iterator erase(iterator it):删除迭代器指针it处元素    iterator erase(iterator first,iterator last):删除[first, last)之间元素    size_type erase(const Key& key):删除元素值等于key的元素[cpp] view plaincopy#include <iostream>  #include <set>  int main ()  {    std::set<int> myset;    std::set<int>::iterator it;    std::pair<std::set<int>::iterator,bool> ret;    // set some initial values:    for (int i=1; i<=5; ++i) myset.insert(i*10);    // set: 10 20 30 40 50    ret = myset.insert(20);               // no new element inserted    if (ret.second==false) it=ret.first;  // "it" now points to element 20    myset.insert (it,25);                 // max efficiency inserting    myset.insert (it,24);                 // max efficiency inserting    myset.insert (it,26);                 // no max efficiency inserting    int myints[]= {5,10,15};              // 10 already in set, not inserted    myset.insert (myints,myints+3);    std::cout << "myset contains:";    for (it=myset.begin(); it!=myset.end(); ++it)      std::cout << ' ' << *it;    std::cout << '\n';    return 0;  }  [cpp] view plaincopy#include <iostream>  #include <set>  int main ()  {    std::set<int> myset;    std::set<int>::iterator it;    // insert some values:    for (int i=1; i<10; i++) myset.insert(i*10);  // 10 20 30 40 50 60 70 80 90    it = myset.begin();    ++it;                                         // "it" points now to 20    myset.erase (it);    myset.erase (40);    it = myset.find (60);    myset.erase (it, myset.end());    std::cout << "myset contains:";    for (it=myset.begin(); it!=myset.end(); ++it)      std::cout << ' ' << *it;    std::cout << '\n';    return 0;  }  4)        遍历函数     iterator begin():返回首元素的迭代器指针    iterator end()：返回尾元素的迭代器指针    reverse_iterator rbegin():返回尾元素的逆向迭代器指针    reverse_iterator rend():返回首元素前一个位置的迭代器指针[cpp] view plaincopy#include <iostream>  #include <set>  int main ()  {    int myints[] = {75,23,65,42,13};    std::set<int> myset (myints,myints+5);    std::cout << "myset contains:";    for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)      std::cout << ' ' << *it;    std::cout << '\n';    return 0;  }  5)        操作函数       const_iterator lower_bound(const Key& key):返回容器中大于等于key的迭代器指针    const_iterator upper_bound(const Key& key):返回容器中大于key的迭代器指针    int count(const Key& key) const:返回容器中元素等于key的元素的个数    pair<const_iterator,const_iterator> equal_range(const Key& key) const:返回容器中元素值等于key的迭代指针[first, last)    const_iterator find(const Key& key) const:查找功能，返回元素值等于key的迭代器指针    void swap(set& s):交换集合元素    void swap(multiset& s):交换多集合元素  [cpp] view plaincopy#include <iostream>  #include <set>  int main ()  {    std::set<int> myset;    std::set<int>::iterator itlow,itup;    for (int i=1; i<10; i++) myset.insert(i*10); // 10 20 30 40 50 60 70 80 90    itlow=myset.lower_bound (30);                //       ^    itup=myset.upper_bound (60);                 //                   ^    myset.erase(itlow,itup);                     // 10 20 70 80 90    std::cout << "myset contains:";    for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)      std::cout << ' ' << *it;    std::cout << '\n';    return 0;  }  [cpp] view plaincopy#include "stdafx.h"  #include <iostream>  #include <set>  using namespace std;  int main ()  {      set<int> myset;      for (int i=1; i<=5; i++) myset.insert(i*10);   // myset: 10 20 30 40 50      pair<set<int>::const_iterator,set<int>::const_iterator> ret;      ret = myset.equal_range(30);      cout << "the lower bound points to: " << *ret.first << '\n';      cout << "the upper bound points to: " << *ret.second << '\n';      return 0;  }  [cpp] view plaincopy#include "stdafx.h"  #include <iostream>  #include <set>  using namespace std;  int main ()  {      int myints[]={12,75,10,32,20,25};      set<int> first (myints,myints+3);     // 10,12,75      set<int> second (myints+3,myints+6);  // 20,25,32      first.swap(second);      cout << "first contains:";      for (set<int>::iterator it=first.begin(); it!=first.end(); ++it)          cout << ' ' << *it;      cout << '\n';      cout << "second contains:";      for (set<int>::iterator it=second.begin(); it!=second.end(); ++it)          cout << ' ' << *it;      cout << '\n';      return 0;  }  

5、map

map/multimap    使用map/multimap之前要加入头文件#include<map>,map和multimap将key/value当作元素，进行管理。它们可根据key的排序准则自动将元素排序。multimap允许重复元素，map不允许重复元素。map和multimap内部的数据结构也是平衡二叉树。    map和multimap根据元素的key自动对元素进行排序，要修改元素的key必须先删除拥有该key的元素，然后插入拥有新的key/value的元素。常用函数1.构造函数和析构函数    map m:创建空映射,不包含任何元素map m(op):以op为排序准则，产生一个空的mapmap m1(m2):复制c2中的元素到c1中map m(const value_type *first, const value_type* last):复制[first, last)之间元素构成新映射map m(const value_type *first, const value_type* last,op):以op为排序准则，复制[first, last)之间元素构成新映射。m.~set()销毁所有元素，释放内存multimap mm:创建空映射,不包含任何元素multimap mm(op):以op为排序准则，产生一个空的multimapmultimap m1(m2):复制m2中的元素到m1中multimap m(const value_type *first, const value_type* last):复制[first, last)之间元素构成新映射multimap m(const value_type *first, const value_type* last,op):以op为排序准则，复制[first, last)之间元素构成新映射m.~multimap()销毁所有元素，释放内存[cpp] view plaincopy#include "stdafx.h"  #include <iostream>  #include <map>  using namespace std;  bool fncomp (char lhs, char rhs) {return lhs<rhs;}  struct classcomp {      bool operator() (const char& lhs, const char& rhs) const      {return lhs<rhs;}  };  int main ()  {      map<char,int> first;      first['a']=10;      first['b']=30;      first['c']=50;      first['d']=70;      map<char,int> second (first.begin(),first.end());      map<char,int> third (second);      map<char,int,classcomp> fourth;                 // class as Compare      bool(*fn_pt)(char,char) = fncomp;      map<char,int,bool(*)(char,char)> fifth (fn_pt); // function pointer as Compare      return 0;  }  2.大小、判断空函数    int size() const:返回容器元素个数    bool empty() const:判断容器是否空，若返回true，表明容器已空。3.增加删除函数    iterator insert(const value_type& x):插入元素x    iterator insert(iterator it,const value_type& x):在迭代指针it处插入元素x    void insert(const value_type *first,const value_type* last):插入[first, last)之间元素    iterator erase(iterator it):删除迭代指针it处元素    iterator erase(iterator first,iterator last):删除[first, last)之间元素    size_type erase(const Key& key):删除键值等于key的元素[cpp] view plaincopy#include "stdafx.h"  #include <iostream>  #include <map>  using namespace std;  int main ()  {      map<char,int> mymap;      mymap.insert(pair<char,int>('a',10));      mymap.insert(pair<char,int>('z',200));      pair<map<char,int>::iterator,bool> ret;      ret = mymap.insert(pair<char,int>('z',500));      if (ret.second == false)      {          cout<<"element 'z' already existed";          cout<<"with a value of "<<ret.first->second<<'\n';      }      map<char,int>::iterator it = mymap.begin();      mymap.insert(it,pair<char,int>('b',300));      mymap.insert(it,pair<char,int>('c',400));      map<char,int> anothermap;      anothermap.insert(mymap.begin(),mymap.find('c'));      cout<<"mymap contains :\n";      for (it = mymap.begin();it!= mymap.end();it++)      {          cout<<it->first<<"=>"<<it->second<<'\n';      }      cout<<"anothermap contains :\n";      for (it = anothermap.begin();it!= anothermap.end();it++)      {          cout<<it->first<<"=>"<<it->second<<'\n';      }      return 0;  }  上述代码运行结果为[cpp] view plaincopy#include "stdafx.h"  #include <iostream>  #include <map>  using namespace std;  int main ()  {      map<char,int> mymap;      map<char,int>::iterator it;      mymap['a'] = 10;      mymap['b'] = 20;      mymap['c'] = 30;      mymap['d'] = 40;      mymap['e'] = 50;      mymap.insert(pair<char,int>('f',60));      cout<<"initial mymap contains :\n";      for (it = mymap.begin();it!= mymap.end();it++)      {          cout<<it->first<<"=>"<<it->second<<'\n';      }      it = mymap.find('b');      mymap.erase(it);      mymap.erase('c');      it = mymap.find('e');      mymap.erase(it,mymap.end());      cout<<"now mymap contains :\n";      for (it = mymap.begin();it!= mymap.end();it++)      {          cout<<it->first<<"=>"<<it->second<<'\n';      }      return 0;  }  上述代码运行结果为：如果想往map/multimap中修改一个映射的值，应先插入一个新映射，再把与修改的映射删除。4.遍历函数        iterator begin():返回首元素的迭代器指针    iterator end()：返回尾元素的迭代器指针    reverse_iterator rbegin():返回尾元素的逆向迭代器指针    reverse_iterator rend():返回首元素前一个位置的迭代器指针5.操作函数       const_iterator lower_bound(const Key& key):返回键值大于等于key的迭代器指针    const_iterator upper_bound(const Key& key):返回键值大于key的迭代器指针    int count(const Key& key) const:返回键值等于key的元素的个数    pair<const_iterator,const_iterator> equal_range(const Key& key) const:返回容器中键值等于key的迭代指针[first, last)    const_iterator find(const Key& key) const:查找功能，返回键值等于key的迭代器指针    void swap(set& s):交换但映射元素    void swap(multiset& s):交换多映射元素  6.特殊函数    reference operator[](const Key& k):仅在但映射map类中，可以以数组的形式给映射添加键-值对，并可返回值的引用。