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) vector<int>v6(v.begin(), v.end());

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

(8) string str[]={"abc", "def", "ghi" };  vector<string>v8(str,str+sizeof(str)/sizeof(string));//类似上面

(9) 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对象会自动扩容。

下表来源：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)

string s;
s="abc123456";
s.replace(3,3,"good"); //从第3个开始，将连续的3个字符替换为“good”,即将“abc”替换为“good”
cout<<s<<endl;

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、用reverse反向排序string对象。reverse头文件<algorithm>，reverse(s.begin(),s.end());

12、与数值间的相互转化

//数值转字符串 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;

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

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

14、其它

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

set

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

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

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

set头文件<set>

1、创建set集合对象。set<int>s;

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

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

5、元素的删除。s.erase(elem); 元素的清空 s.clear();

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

set<int>s;
s.insert(4);
s.insert(3);
s.insert(7);
s.insert(1);
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;
//反向遍历集合中元素
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";
//结合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）

时间： 2024-10-09 18:00:04

STL学习：STL库vector、string、set、map用法的相关文章

标准模板库(STL)学习探究之vector容器

标准模板库(STL)学习探究之vector容器  C++ Vectors vector是C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库.vector之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据.为了可以使用vector,必须在你的头文件中包含下面的代码:#include <vector>构造函数. Vectors 包含着一系列连续存储的元素,其行为和数组类

STL学习篇：vector的简单使用

vector,一个动态数组!在堆中操作,元素连续存放,可以直接访问其中的任何元素,初始分配有内存,当保留内存不够的时候,会再分配内存! 下面看一个vector的构造函数例子: 1 #include <iostream> 2 #include<vector> 3 #include<string> 4 5 int main() 6 { 7 using namespace std; 8 9 //类模板,模板参数 10 vector<int> ivec;//保存in

STL学习二：Vector容器

1.Vector容器简介 vector是将元素置于一个动态数组中加以管理的容器. vector可以随机存取元素(支持索引值直接存取, 用[]操作符或at()方法,这个等下会详讲). vector尾部添加或移除元素非常快速.但是在中部或头部插入元素或移除元素比较费时. 2.vector对象的默认构造 vector采用模板类实现,vector对象的默认构造形式 vector<T> vecT; vector<int> vecInt;          //一个存放int的vector容器

C++STL学习笔记_(1)string知识

/*============================================ string是STL的字符串类型,通常用来表示字符串 = ============================================*/ #include <iostream> using namespace std; #include "string"//string的头文件 #include "algorithm" /*============

【stl学习笔记】vector

vector是定义于namespace std内的template: namespace std { template<class T, class Allocator = allocator<T>> class vector; } vector优异性能的秘诀之一,就是配置比其所容纳的元素所需更多的内存.capacity()函数返回vector实际能够容纳的元素数量.如果超越这个数量,vector就要重新配置内部存储器. vector的容量之所以重要,是因为: 1.一旦内存重新配置

STL标准容器类学习笔记之(Vector/Deque/List)

STL标准容器类简介 1.顺序性容器 vector相当与数组,从后面快速的插入与删除,直接访问任何元素 deque双队列,从前面或后面快速的插入与删除,直接访问任何元素 list双链表,从任何地方快速插入与删除 2.关联容器 set快速查找,不允许重复值 multiset快速查找,允许重复值 map一对一映射,基于关键字快速查找,不允许重复值 multimap一对多映射,基于关键字快速查找,允许重复值 3.容器适配器 stack后进先出 queue先进先出 priority_queue最高优先级

C++学习STL之关联容器 --- pair、map、set

本博文我们继续讨论标准模板库STL的关联容器: 主要有:pair.map.set. 一:pair pair是一种简单的关联类型,不属于容器范围.而是代表一个 key-value键值对. 创建.初始化.操作 示例代码如下: 1 #include <iostream> 2 #include <string> 3 #include <vector> 4 using namespace std; 5 //将pair放入容器&initpair 6 int main(int

STL中常用的vector，map，set 用法

STL中常用的vector,map,set 用法 C++的标准模板库(Standard Template Library,简称STL)是一个容器和算法的类库.容器往往包含同一类型的数据.STL中比较常用的容器是vector,set和map,比较常用的算法有Sort等. . 一. vector 1.声明: 一个vector类似于一个动态的一维数组. vector中可以存在重复的元素! vector<int> a;          // 声明一个元素为int类型的vector a vectot&

C++ STL学习——vector

学过C++的人肯定会很熟悉STL标准模板库,STL其实就是封装了一系列的接口,供我们调用.很多函数或者算法的实现不需要我们从头开始写,大大提高我们的编程效率.这篇博客在简单介绍STL的情况下,会详细的来介绍vector的使用. STL共有六大组件: 一.容器(Container):是一种数据结构,如list,vector,deque,queue等,以模板类的方法提供,为了访问容器中的数据,可以使用由容器类提供的迭代器. 二.迭代器(Iterator):提供了访问容器中对象的方法. 三.算法(Al