STL学习：STL库vector、string、set、map用法

本文仅介绍了如何使用它们常用的方法。

vector

1、可随机访问，可在尾部插入元素；2、内存自动管理；3、头文件#include <vector>

1、创建vector对象

一维：

　　(1) vector<int>v1;

　　(2) vector<int>v2(10);//10个元素，初始为0

　　(3) vector<int>v3(10,4);//10个元素，初始为4

　　(4) vector<int>v4(v3);

　　(5) vector<int>v5=v4;

　　(6) 利用迭代区间[&begin, &end]所指的元素

　　　　1)vector<int>v6(v.begin(), v.end());

　　　　2)set<int>s; vector<int>v(s.begin(), s.end());

　　　　3)int a[4]={1,2,3}; vector<int>v7(a,a+sizeof(a)/sizeof(a[0]));

　　　　4)string str[]={"abc", "def", "ghi" };  vector<string>v8(str,str+sizeof(str)/sizeof(string));

　　　　5)char *s[]={"abc", "def", "ghi" };  vector<string>v9(s,s+sizeof(s)/sizeof(int));

二维：

(1) int n=3, m=4; vector<vector<int>>matrix(n, m);//创建一个n行m列初始值为0的二维vector对象

(2) vector<vector<int>>mat(n,vector<int>(m,9));//赋初值为9

note： mat.size(); mat[0].size();

2、尾部元素扩张：v.push_back(elem);

3、下标方式访问：v[index]=elem; cout<<v[index]; 下面遍历二维向量

int a[]={1,2,3,4,5};
vector<int>v(a,a+sizeof(a)/sizeof(a[0]));
vector<vector<int>>mat(3,v);
for(size_t i =0; i<mat.size(); i++){
    for(size_t j=0; j<mat[i].size(); j++)
        cout<<mat[i][j];
    cout<<endl;
}

4、v.at(index)访问：mat.at(1).at(2)=433;  cout<<mat.at(1).at(2);//二维举例

5、用迭代器访问与遍历：

begin()、end()、rbegin()、rend()：begin()返回的是首元素位置的迭代器；end()返回的是最后一个元素的下一元素位置的迭代器。rbegin()、rend()与他们相反。

vector<int>::iterator it; 
for(it=v.begin();it!=v.end();it++) 
     cout<<*it<<" "; 
//使用auto,代码显得简洁
for(auto i=v.begin(); i!=v.end(); i++)
    cout<<*i<<" ";
//反向遍历 迭代器为reverse_iterator
for(auto i=v.rbegin(); i!=v.rend(); i++)
    cout<<*i<<" ";

//这两种遍历方式对于其它类也可用

int arr[5]={10,20,30,40,50};
vector<int>vec(arr,arr+sizeof(arr)/sizeof(arr[0]));
cout<<(*vec.begin())+2<<endl;//12
cout<<*(vec.begin()+2)<<endl;//30
cout<<*vec.begin()+2<<endl;//12
//*操作符优先级大于+操作符的优先级

6、元素的插入（insert把一个数据插入到迭代器位置之前） v.insert(pos,elem)  v.insert(pos,n,elem)  v.insert(pos,beg,end)

vector<int>v(10);
int a[]={1,2,3,4,5,6,7};
vector<int>v1(a,a+sizeof(a)/sizeof(a[0]));
v.insert(v.begin()+1, v1.begin(),v1.begin()+3);
for(auto i=v.begin(); i!=v.end(); i++)
    cout<<*i;
cout<<*(v1.begin()+3)<<endl;
//v.insert(pos,beg,end); 拷贝区间为[beg,end)

7、元素的删除  v.erase(pos) v.erase(beg,end)。区间为[beg,end)。

8、使用reverse反向排列算法，头文件<algorithm>

reverse(v.begin(),v.end());

 

9、sort排序

　　(1)sort(v.begin(),v.end());//默认为升序

　　(2)sort(v.begin(),v.end(),cmp);//以cmp条件函数排序

10、size() 与 capacity()、reserve()与resize()

　　(1) capacity指的是容量，size指的是实际元素的个数。size<=capacity

　　(2) 当元素大于容量时，容量函数增加。

　　(3)empty()方法返回向量是否为空，指的是实际数据个数。

　　(4)reserve()和resize()分别是对capacity与size的重设，当发生异常时，vector对象会自动扩容。

11、使用swap(v1,v2)交换两对象。（对于其它类也适用，后面不在赘述）

下表来源：http://blog.csdn.net/phoebin/article/details/3864590

string

头文件<string>

1、创建string对象： string s;

2、给string对象赋值：

(1) s=”abc”;

(2)把字符指针赋给一个字符串对象。

char *c1="abcde";
char c2[]={'f','g','h','\0'};
string s=c1;
s+=c2;
cout<<s<<endl;

3、在尾部添加字符、字符串

string s;
s+='a';
s.push_back('b');//注意，不能用这个方法添加字符串
s.pop_back();
s+="cde";
s.append("f");//不能用这个方法添加字符
cout<<s<<endl;

4、插入字符 （insert()方法把一个字符插入到迭代器位置之前）。s.insert(pos, char)，s.insert(pos,n,elem)  s.insert(pos,beg,end)

5、下标方式访问。

6、删除元素。(1)s=“”；(2)earse()

7、返回长度。s.length()或者s.size()

8、替换string对象的字符，常用的replace(beginIndex,len,str)，swap

string s; 
s="789123456"; 
s.replace(3,3,"good"); //从第3个开始，将连续的3个字符替换为“good”,即将“abc”替换为“good”
cout<<s<<endl;
//用swap替换
string s2="ddddd";
swap(s[2],s2[2]);
cout<<s;

 

9、搜索string对象的元素或子串。find()

//find()方法可查找字符、字符串,未找到返回string::npos的值(4294967295)
//find 必须匹配完整的字符串，find_first_of只需要匹配部分即可（group）
string s="  acbac  ";
cout<<s.find("ab")<<endl;//2,返回字符串的首位下标
cout<<s.find_first_not_of(' ')<<endl;//2
cout<<s.find_first_of("1234567a")<<endl;//2,只需符合该组中一个元素即可
cout<<s.find_last_not_of(' ')<<endl;//4
cout<<s.find_last_of('c')<<endl;//4
cout<<s.rfind('a')<<endl;//4,从尾部向前搜索，返回找到的第一个
int a=s.find("ab");
printf("%d", a==string::npos);//1,没有找到，返回npos

10、字符串的比较。 compare()

//如果它比对方大，则返回1；如果它比对方小，则返回-1；如果它与对方相同（相等），则返回0。
string s1="12345";
string s2="fgger";
cout<<s1.compare(s2)<<endl;
//判断是否相同可以直接用比较运算符
bool isq=s1==s2;
cout<<isq<<endl;
isq="1"=="1";
cout<<isq<<endl;

11、sort方法排序。（头文件<algorithm>）

bool cmp(char c1, char c2)
{
    if(c1>c2) return true;
    else return false;
}
int main()
{
    string s;
    cin>>s;
    sort(s.begin(), s.end(), cmp);
    cout<<s;

    system("pause");
    return 0;
}

12、用reverse反向排序string对象。reverse头文件<algorithm>，reverse(s.begin(),s.end());

13、与数值间的相互转化

//数值转字符串 C++方法，使用<sstream>中的ostringstream流
double d=1.34;
ostringstream o;
if(o << d)  //把数值d输入流中
    cout<<o.str()<<endl;
else
    cout<<"conversion error"<<endl;
//字符串转数值 C++方法，使用<sstream>中的istringstream流
string s3="1234.234";
istringstream i(s3); //把字符串放入流中
double d2;
if(i >> d2) //从流中输出d
    cout<<d2<<endl;
else d2=0.0;
//将数值转换为string：C方法,使用sprintf函数
char b[10]; 
string a; 
sprintf(b,"%d",1975); //不能直接打印到string上，sprintf是C函数
a=b; 
cout<<a<<endl;

14、printf打印string对象。采用c_str()方法（printf是C函数，string属于C++）

printf(s.c_str()); 

printf("%s",s);//这是错的

15、其它

了解C函数sscanf()、sprintf()的使用

set

set集合容器实现了红黑树（Red-Black Tree）的平衡二叉检索树的数据结构，在插入元素时，它会自动调整二叉树的排列，把该元素放到适当的位置，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值；另外，还得确保根节点左子树的高度与右子树的高度相等，这样，二叉树的高度最小，从而检索速度最快。要注意的是，它不会重复插入相同键值的元素，而采取忽略处理。multiset（多重集合容器）、map（映照容器）和multimap（多重映照容器）的内部结构也是平衡二叉检索树。

set元素不可重复，multiset元素可重复。

对应的不排序的集合：unordered_set，头文件<unordered_set>

set头文件<set>

推荐博客：http://www.cppblog.com/huyutian/articles/107457.html

1、创建set集合对象。

　　(1)set<int>s;

　　(2)set<int>s2(s1);

　　(3)set<int, myComp>s3;//使用自定义比较函数

　　(4)利用迭代区间[&begin, &end]所指的元素（参考vector）

　　　　int arr[]={1,2,4,3}; set<int>s4(arr,arr+sizeof(arr)/sizeof(arr[0]));

　　　　vector<int>v(arr,a+sizeof(arr)/sizeof(arr[0])); set<int>s(v.begin(), v.end());

　　(5)利用迭代区间[&begin, &end]所指的元素和自定义比较函数

　　　　const char* carr[] = {"ab", "cd", "ef" };

　　　　set<const char*, myComp> s5(carr, carr+ 3, myCmop() );

2、插入元素。用insert(elem)方法把元素按顺序插入集合,若重复插入某元素，则后来的插入无效，但不会出错。

　　(1)插入value，返回pair配对对象，可以根据.second判断是否插入成功。(提示:value不能与set容器内元素重复)
　　pair<iterator, bool> insert(value)
　　(2)在pos位置之前插入value，返回新元素位置，但不一定能插入成功
　　iterator insert(&pos, value)
　　(3)将迭代区间[&first, &last)内所有的元素，插入到set容器
　　void insert[&first, &last)

3、元素的反向遍历（参考vector的反向遍历或下面代码）。

5、元素的删除。

　　(1)size_type erase(value) 移除set容器内元素值为value的所有元素，返回移除的元素个数
　　(2)void erase(&pos) 移除pos位置上的元素，无返回值
　　(3)void erase(&first, &last) 移除迭代区间[&first, &last)内的元素，无返回值
　　(4)void clear()， 移除set容器内所有元素

6、元素的检索。使用find(),如果找到查找的键值，则返回该键值的迭代器位置，否则，返回集合最后一个元素后面的一个位置，即end()。

int arr[]={4,3,7,1,7,0};
set<int>s(arr, arr+sizeof(arr)/sizeof(arr[0]));//对于arr中重复的元素，不会重复插入
s.insert(3);//重复元素，不会插入
s.erase(3);//将元素3擦除
auto it= s.find(3);//查找元素3，找到返回迭代器位置，否则返回s.end()
if(it!=s.end())
    cout<<"found "<<*it<<endl;
else
    cout<<"not found!"<<endl;
if(s.insert(7).second)//返回pair配对对象，可以根据.second判断是否插入成功
    cout<<"OK"<<endl;
else 
    cout<<"fail"<<endl;
//反向遍历集合中元素
set<int>::reverse_iterator i;
for(i=s.rbegin(); i!=s.rend(); i++)
    cout<<*i<<" ";

 

7、自定义比较函数。使用insert()将元素插入到集合中去的时候，集合会根据设定的比较函数将该元素放到该放的节点上去。在定义集合的时候，如果没有指定比较函数，那么采用默认的比较函数，即按键值由小到大的顺序插入元素。在很多情况下，需要自己编写比较函数。编写比较函数有两种方法。
（1）如果元素不是结构体，那么，可以编写比较函数。

//自定义比较函数myComp，重载“()”操作符
struct myComp 
{ 
    bool operator()(const int &a,const int &b) 
    { 
        if(a!=b)  return a>b; 
        else return a>b; 
    } 
}; 

int main()
{
    set<int, myComp>s;
    s.insert(4);
    s.insert(3);
    s.insert(7);
    s.insert(1);
    s.insert(3);//重复元素，不能插入
    s.erase(3);//将元素3擦除
    set<int, myComp>::iterator i;
    for(i=s.begin(); i!=s.end(); i++)
        cout<<*i<<" ";
    system("pause");
    return 0;
}

（2）如果元素是结构体，那么，可以直接把比较函数写在结构体内。

struct Info 
{ 
    string name; 
    float score; 
    //重载“<”操作符，自定义排序规则
    bool operator < (const Info &a) const 
    { 
        //按score由大到小排列。如果要由小到大排列，使用“>”号即可。
        return a.score<score;  } 
}; 

int main()
{
    //定义元素类型为Info结构体的集合对象s，当前没有任何元素
    set<Info> s; 
    //定义Info类型的元素
    Info info; 
    //插入3个元素
    info.name="Jack"; 
    info.score=80.5; 
    s.insert(info); 
    info.name="Tomi"; 
    info.score=20.5; 
    s.insert(info); 
    info.name="Nacy"; 
    info.score=60.5; 
    s.insert(info); 
    set<Info>::iterator it;//定义前向迭代器
    for(it=s.begin();it!=s.end();it++) 
    { 
        cout<<(*it).name<<" : "<<(*it).score<<endl; 
    }
    system("pause");
    return 0;
}

map

map映照容器的元素数据是由一个键值和一个映照数据组成的，键值与映照数据之间
具有一一映照的关系。键值不可重复，并按照键值排序。multimap多重映照容器，键值可重复

头文件<map>

对应的不排序的unordered_set，头文件<unordered_map>

1、map创建、元素插入和遍历访问

map<int,string>m;
m[1]="a"; m[4]="b"; m[3]="c"; m[7]="e";
m[6]="f"; m[5]="g";
m[7]+="0";//键值重复，对应的数据将修改
cout<<m[7];
//结合pair插入元素//
map<int,string>mp;
pair<int,string>p;
p=make_pair(1,"q");
mp.insert(p);
auto mb=mp.begin(); auto me=mp.end();
cout<<mb->first<<; cout<<(*mb).second<<endl; 
cout<<(*mp.begin()).first; cout<<(*mp.begin()).second;
for(auto i=m.begin(); i!=m.end(); i++)//遍历输出
cout<<(*i).first<<" : "<<(*i).second<<endl;

 

 

2、删除元素。m.erase(key)

3、反向遍历。（参考vector)

4、元素的搜索。find(),（参考set）

5、自定义比较函数。（两种，结构体，或者非结构体，参考set）

 

参考资料《（STL学习）acm程序设计曾宗根》