STL emm.....

最新推荐文章于 2024-07-24 14:05:37 发布

喝个罐装

最新推荐文章于 2024-07-24 14:05:37 发布

阅读量135

点赞数

文章标签： c++

本文链接：https://blog.csdn.net/D13785585503/article/details/123969887

版权

关于STL的emm

STL的认识

STL（Standard Template Library)，就是标准模板库。

其中它包括六大部分：容器，算法，迭代器，仿函数，适配器（配接器），空间配置器。

主要了解前四部分

其中容器和算法需要用到迭代器来进行链接。

容器

用来容纳、包含相同类型元素的对象，主要用类模板实现

其中分为两种类型的容器

1.序类型容器

容器中元素按照线形顺序结构组织起来，可以逐个读写元素。

包括vector,deque,list

2.关联型容器

通过一定的关系进行组织，不受特定的物理条件束缚，强调之间的联系。

包括stack，queue

迭代器

是用来确定元素位置的数据类型，可以用来遍历容器中的元素

迭代器相当于指针

例如

//vecror的迭代器：
vector<int>::iterator it;
//其中 it 相当于一个指针，如果要获取其中的元素，可用：*it
//容器类名<元素类型>::iterator 变量名

算法

STL中提供的算法涉及到很多，比如交换，比较，查找，遍历，复制，修改，删除，排序，合并等等

其中算法需要用到迭代器来操纵容器中的元素

算法可以处理容器，也可以处理C语言数组

Vector

首先用到vector容器时要包括以下头文件：

#include<vector>

创建一个vector容器变量

vector<int> v;
//存放int类型的容器v

push_back()

这个函数是用来在容器尾部插入元素的作用。

    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);

begin()和end()

begin() 用来获取vector容器第一个元素的信息

end() 用来获取vector容器最后一个元素的下一个位置的信息

遍历算法

1.下标访问

就把vector容器理解为一个数组，和遍历数组的操作大同小异。

2.迭代器访问

 for(vector<int>::iterator it=v.begin();it!=v.end();it++)
  {
      cout<<*it<<endl;
  }

3.for_each函数

#include <iostream>
#include<vector>
using namespace std;
#include<algorithm>//用for_each函数一定要用这个头文件，其中algorithm就是算法的意思
void printl(int a)//for_each函数中的第三个参数，构造这个函数在遍历过程中使用，类似于回调函数的作用。
{
    cout<<a;
}

void test01()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);


  for_each(v.begin(),v.end(),printl);

}


int main()
{
    test01();
    return 0;
}

vector 容器的嵌套使用

其中vector<vector >v;

v可以看做是一个int类型的二维数组。

#include <iostream>
#include<vector>
using namespace std;
#include<algorithm>


void test01()
{
    vector<vector<int> >v;
    vector<int> v1;
    vector<int> v2;
    vector<int> v3;
    vector<int> v4;

    for(int i=0;i<4;i++)
    {
        v1.push_back(i+1);
        v2.push_back(i+2);
        v3.push_back(i+3);
        v4.push_back(i+4);
    }

    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    v.push_back(v4);
//首先it就是一个迭代器的具象化，*it是将其解引用，则表示一个vector<int>类型的一个变量，
//所以*it就相当于一个容器 vector<int>，所以用*it配合begin和end函数来起到一个获取容器元素信息的作用
//并且因为编译器的原因，在嵌套使用容器的时候>>符号之间要用空格隔开，否则编译器会报错！！！，必须写成> >的样子
    for(vector<vector<int> >::iterator it=v.begin();it!=v.end();it++)
    {
        for(vector<int>::iterator vit=(*it).begin();vit!=(*it).end();vit++)
        {
            cout<<*vit<<" ";
        }
        cout<<endl;
    }

}


int main()
{
    test01();
    return 0;
}

String

string构造函数

    //1.直接构造
    string str1;
    str1="1212";
    cout<<str1<<endl;

    //2.利用string对象进行构造
    string str2;
    str2="2222";
    string str3(str2);
    cout<<str3<<endl;

    //3.利用字符串进行构造
    const char* c="sdada";
    string str4(c);
    cout<<str4<<endl;

    //4.初始化6个a
   string str5(6,'a');
    cout<<str5<<endl;

string赋值操作

    //1.直接初始化字符串
    string str1="aaaaa";
    cout<<str1<<endl;

    //2.利用字符串进行赋值operator+;
    string str2;
    str2=str1;
    cout<<str2<<endl;

    //3.将字符赋值给字符串
    string str3;
    str3='a';
    cout<<str3<<endl;

    //4.利用assign(const char*)函数
    string str4;
    const char* c="ssss";
    str4.assign(c);
    cout<<str4<<endl;

    //5.利用assign(const string& s)函数
    string str5;
    str5.assign(str1);
    cout<<str5<<endl;

    //6.利用assign(int n,char c)函数
    string str6;
    str6.assign(6,'a');
    cout<<str6<<endl;

    //7.利用assign(const char*,int n)函数，及将其中前n个字符赋值给字符串
    string str7;
    str7.assign(c,2);
    cout<<str7<<endl;

string拼接

拼接就是将字符串接到string对象的最后端

    //1.operator+=操作直接拼接,可拼接直接的值、字符串、string对象。
    string str1="abc";
    cout<<str1<<endl;
    //str1+="def";
    //cout<<str1<<endl;
    string str2="ghi";
    //str1+=str2;
    //cout<<str1<<endl;
    const char* c="jkl";
    //str1+=c;
    //cout<<str1<<endl;

    //2.append()函数一个参数的接法
    str1.append("def");
    cout<<str1<<endl;
    str1.append(str2);
    cout<<str1<<endl;
    str1.append(c);
    cout<<str1<<endl;

    //3.append(const char*,int n)截取前n个进行后接
    str1.append("mnopq",3);
    cout<<str1<<endl;

    //4.append(const char*,int pos,int n)每个char*的首地址都是0。
    str1.append("pqrstuvwxyz",0,3);
    cout<<str1<<endl;

string查找

注意区分find和rfrind的区别

    //find函数和rfind函数的都是int类型的返回值
    //位置下标从0开始，find函数是从左往右查找
    string str1="abcdefgcde";
    int pos;
    pos=str1.find("cd");
    cout<<"pos = "<<pos<<endl;
    pos=str1.find("zsc");
    cout<<"pos = "<<pos<<endl;//如果没有找到就返回值-1
    int rpos;
    rpos=str1.rfind("cd");
    cout<<"rpos = "<<rpos<<endl;
    //rfind函数是从右向左去寻找，但是返回的下标值还是从左向右进行计算

string替换

    //replace(int pos,int n,string &s)从pos开始n个字符替换成s，但是当n小于s的长度时，将s全部将被替换进去,当n大于s的长度     时，原字符串多余的值也会消失。
    string str1="abcdefg";
    str1.replace(0,3,"1111");
    cout<<"str1 = "<<str1<<endl;
    //结果为1111defg
    
    string str2="higklmn";
    str2.replace(0,5,"1111");
    cout<<"str2 = "<<str2<<endl;
    //结果为1111mn

string判断大小

    //利用compare函数进行比较，函数返回值类型为int类型如果两个字符串相等返回0，大于返回1，小于返回-1
    string str1="abc";
    string str2="abc";
    int p=str1.compare(str2);
    if(!p)
        cout<<"equal"<<endl;
    else
        cout<<"none"<<endl;

string字符的访问

    string str1="abcdefgh";
    //利用[]重载运算符进行访问
    for(int i=0;i<str1.size();i++)
    {
        cout<<str1[i]<<" ";
    }
    cout<<endl;
    //利用at函数进行访问
    for(int i=0;i<str1.size();i++)
    {
        cout<<str1.at(i)<<" ";
    }

string字符的插入

    //插入用到insert函数
    string str1="abcdefg";
    cout<<str1<<endl;
    //1.insert(int pos,const char* c/const &string s)
    const char* c="a32s";
    str1.insert(1,"665");
    cout<<str1<<endl;
    str1.insert(2,c);
    cout<<str1<<endl;

    //2.insert(int pos,int n,char c)从pos位置开始，插入n个字符c
    string str2="12145";
    str2.insert(1,8,'a');
    cout<<str2<<endl;

string字符的删除

    //删除用到erase函数：erase(int pos,int n)从pos开始删除n个字符
    string str="123456789";
    str.erase(5,2);
    cout<<str<<endl;

string获取子串

    //子串的获取用到substr函数：substr(int pos,int n)
    string str="xinlang@454.com";
    cout<<str.substr(0,6)<<endl;

    //结合find函数可以截取想要的字符子串，比如截取xinlang,find函数的值去找要截取子串最后一个字符的下一个字符的位置，这个位置的值就是要截取子串的长度（从头开始截取，如果不是要加上相应的值，也可借助find函数去查找）
    int pos=str.find('@');
    cout<<str.substr(0,pos)<<endl;

substr函数应用比较多

string实验代码

#include <iostream>
#include<string>
using namespace std;
/*
void test01()
{
    //1.直接构造
    string str1;
    str1="1212";
    cout<<str1<<endl;

    //2.利用string对象进行构造
    string str2;
    str2="2222";
    string str3(str2);
    cout<<str3<<endl;

    //3.利用字符串进行构造
    const char* c="sdada";
    string str4(c);
    cout<<str4<<endl;

    //4.初始化6个a
   string str5(6,'a');
    cout<<str5<<endl;
}
*/
/*
void test02()
{
    //1.直接初始化字符串
    string str1="aaaaa";
    cout<<str1<<endl;

    //2.利用字符串进行赋值operator+;
    string str2;
    str2=str1;
    cout<<str2<<endl;

    //3.将字符赋值给字符串
    string str3;
    str3='a';
    cout<<str3<<endl;

    //4.利用assign(const char*)函数
    string str4;
    const char* c="ssss";
    str4.assign(c);
    cout<<str4<<endl;

    //5.利用assign(const &string)函数
    string str5;
    str5.assign(str1);
    cout<<str5<<endl;

    //6.利用assign(int n,char c)函数
    string str6;
    str6.assign(6,'a');
    cout<<str6<<endl;

    //7.利用assign(const char*,int n)函数，及将其中前n个字符赋值给字符串
    string str7;
    str7.assign(c,2);
    cout<<str7<<endl;
}
*/

/*
void test03()
{
    //1.operator+=操作直接拼接,可拼接直接的值、字符串、string对象。
    string str1="abc";
    cout<<str1<<endl;
    //str1+="def";
    //cout<<str1<<endl;
    string str2="ghi";
    //str1+=str2;
    //cout<<str1<<endl;
    const char* c="jkl";
    //str1+=c;
    //cout<<str1<<endl;

    //2.append()函数一个参数的接法
    str1.append("def");
    cout<<str1<<endl;
    str1.append(str2);
    cout<<str1<<endl;
    str1.append(c);
    cout<<str1<<endl;

    //3.append(const char*,int n)截取前n个进行后接
    str1.append("mnopq",3);
    cout<<str1<<endl;

    //4.append(const char*,int pos,int n)每个char*的首地址都是0。
    str1.append("pqrstuvwxyz",0,3);
    cout<<str1<<endl;
}
*/
/*
void test04()
{
    //find函数和rfind函数的都是int类型的返回值
    //位置下标从0开始，find函数是从左往右查找
    string str1="abcdefgcde";
    int pos;
    pos=str1.find("cd");
    cout<<"pos = "<<pos<<endl;
    pos=str1.find("zsc");
    cout<<"pos = "<<pos<<endl;//如果没有找到就返回值-1
    int rpos;
    rpos=str1.rfind("cd");
    cout<<"rpos = "<<rpos<<endl;
    //rfind函数是从右向左去寻找，但是返回的下标值还是从左向右进行计算

}
*/
/*
void test05()
{
    //replace(int pos,int n,string &s)从pos开始n个字符替换成s，但是当n小于s的长度时，将s全部将被替换进去,当n大于s的长度时，原字符串多余的值也会消失。
    string str1="abcdefg";
    str1.replace(0,3,"1111");
    cout<<"str1 = "<<str1<<endl;
    //结果为1111defg

    string str2="higklmn";
    str2.replace(0,5,"1111");
    cout<<"str2 = "<<str2<<endl;
    //结果为1111mn
}
*/

/*
void test06()
{
    //利用compare函数进行比较，函数返回值类型为int类型如果两个字符串相等返回0，大于返回1，小于返回-1
    string str1="abc";
    string str2="abc";
    int p=str1.compare(str2);
    if(!p)
        cout<<"equal"<<endl;
    else
        cout<<"none"<<endl;
}
*/
/*
void test07()
{
    string str1="abcdefgh";
    //利用[]重载运算符进行访问
    for(int i=0;i<str1.size();i++)
    {
        cout<<str1[i]<<" ";
    }
    cout<<endl;
    //利用at函数进行访问
    for(int i=0;i<str1.size();i++)
    {
        cout<<str1.at(i)<<" ";
    }
}
*/
/*
void test08()
{
    //插入用到insert函数
    string str1="abcdefg";
    cout<<str1<<endl;
    //1.insert(int pos,const char* c/const &string s)
    const char* c="a32s";
    str1.insert(1,"665");
    cout<<str1<<endl;
    str1.insert(2,c);
    cout<<str1<<endl;

    //2.insert(int pos,int n,char c)从pos位置开始，插入n个字符c
    string str2="12145";
    str2.insert(1,8,'a');
    cout<<str2<<endl;

}

*/

/*
void test09()
{
    //删除用到erase函数：erase(int pos,int n)从pos开始删除n个字符
    string str="123456789";
    str.erase(5,2);
    cout<<str<<endl;
}
*/

/*
void test10()
{
    //子串的获取用到substr函数：substr(int pos,int n)
    string str="xinlang@454.com";
    cout<<str.substr(0,6)<<endl;

    //结合find函数可以截取想要的字符子串，比如截取xinlang,find函数的值去找要截取子串最后一个字符的下一个字符的位置，这个位置的值就是要截取子串的长度（从头开始截取，如果不是要加上相应的值，也可借助find函数去查找）
    int pos=str.find('@');
    cout<<str.substr(0,pos)<<endl;

}

*/
int main()
{
    //test01();
    //test02();
    //test03();
    //test04();
    //test05();
    //test06();
    //test07();
    //test08();
    //test09();
    //test10();
    return 0;
}

Vector2

vector类似于单端数组，可以动态扩展（当空间不够时，重新找一块更大的空间，将原来的信息拷贝过去），并且vector的迭代器支持随机访问。

vector的构造函数

    //1.无参形式的模板构造vector<T> v,T为参数类型
    vector<int> v1;
    for(int i=0;i<10;i++)
        v1.push_back(i);
    PrintVector(v1);

    //2.区间构造vector(v.begin(),v.end()),区间左闭右开
    vector<int> v2(v1.begin(),v1.end());
    PrintVector(v2);

    //3.构造n个elem值的容器 vector(n,elem)
    vector<int>v3(5,100);
    PrintVector(v3);

vector的赋值操作

  vector<int>v1;
  for(int i=0;i<10;i++)
       v1.push_back(i);
        PrintVector(v1);

  //1.利用运算符重载vector operator=(const vector&v)
  vector<int>v2;
  v2=v1;
  PrintVector(v2);

  //2.利用assign(v.beign(),v.end())函数,左闭右开
  vector<int>v3;
  v3.assign(v1.begin(),v1.end());
  PrintVector(v3);

  //3.利用assign(n,elem)函数，赋值n个elem
  vector<int>v4;
  v4.assign(10,666);
  PrintVector(v4);

vector的容量和大小的获取

    //empty()函数用来判断是否为空；capacity()函数用来得到容器的容量；size()函数用来得到容器的元素个数
    vector<int>v;
    for(int i=0;i<10;i++)
        v.push_back(i);
    PrintVector(v);
    if(v.empty())
    {
        cout<<"容器为空"<<endl;
    }
    else
    {
        cout<<"容器未空"<<endl;
        cout<<"容器的容量为："<<v.capacity()<<endl;
        cout<<"容器的元素个数为:"<<v.size()<<endl;
    }
  //resize(int n，int elem)调整容器的长度为n，并且如果容器变长，则将elem填充相应空位置（如果没有这个参数elem，就默认为0）；如果容器变短，则多余的元素被删除
  v.resize(2,2);
 cout<<"容器的容量为："<<v.capacity()<<endl;
 cout<<"容器的元素个数为:"<<v.size()<<endl;
 PrintVector(v);

vector插入和删除

    vector<int>v;
    for(int i=0;i<10;i++)
    {
        v.push_back(i);//尾部添加元素
    }
    PrintVector(v);

    v.pop_back();//pop_back()函数用来去除最尾端的元素
    PrintVector(v);

    //insert(iterator,elem),在迭代器对应的位置插入元素elem
    v.insert(v.begin()+1,666);
    PrintVector(v);

    //insert(iterator,n,elem),在迭代器对应的位置插入n个元素elem
    v.insert(v.begin(),3,999);
    PrintVector(v);

    //erase(iterator)删除迭代器所指向的元素
    v.erase(v.begin()+4);
    PrintVector(v);

    //erase(iterator1,iterator2)删除从迭代器1到迭代器2之间的元素,区间左闭右开
    //v.erase(v.begin(),v.end());
    //上述表达式和v.clean()相同的效果
    v.clear();
    PrintVector(v);

vector的数据存取

   vector<int>v;
   for(int i=0;i<10;i++)
        v.push_back(i);
   PrintVector(v);
   //1.利用at函数访问vector容器的数据
   for(int i=0;i<v.size();i++)
   {
       cout<<v.at(i)<<" ";
   }
   cout<<endl;

   //2.利用重载[]运算符访问vector容器的数据
   for(int i=0;i<v.size();i++)
    cout<<v[i]<<" ";
   cout<<endl;

   //3.front函数访问vector容器的第一个元素
   cout<<v.front()<<endl;

   //4.back函数访问vector容器的最后一个元素
   cout<<v.back()<<endl;

vector的互换容器

    cout<<"交换前："<<endl;
    vector<int>v1;
    for(int i=0;i<10;i++)
        v1.push_back(i);
        PrintVector(v1);
    vector<int>v2(10,666);
    PrintVector(v2);
    cout<<"交换后："<<endl;
    v1.swap(v2);
    PrintVector(v1);
    PrintVector(v2);

    //利用匿名对象结合swap函数起到收缩内存空间的作用
    vector<int>(v1).swap(v1);

vector预留空间

    //reserve函数用来预留空间，为了减少vector在动态扩容的次数，并且预留的空间不能被访问
    vector<int>v;
    //v.reserve(100000);当不存在reserve函数是num值是18，当预留空间时num值为1
    int num=0;//扩展次数
    int *p=NULL;
    for(int i=0;i<100000;i++)
    {
        v.push_back(i);
        if(p!=&v[0])//因为每次vector动态扩容是重新找一块地址空间，不是在后添加，所以每次动态扩容，容器首元素的位置都会改变。
        {
            p=&v[0];
            num++;
        }
    }
    cout<<num<<endl;

vector实验代码

#include <iostream>
#include<vector>
using namespace std;
void PrintVector(vector<int>&v)
{
    for(vector<int>::iterator it=v.begin();it!=v.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}
/*
void test01()
{
    //1.无参形式的模板构造vector<T> v,T为参数类型
    vector<int> v1;
    for(int i=0;i<10;i++)
        v1.push_back(i);
    PrintVector(v1);

    //2.区间构造vector(v.begin(),v.end()),区间左闭右开
    vector<int> v2(v1.begin(),v1.end());
    PrintVector(v2);

    //3.构造n个elem值的容器 vector(n,elem)
    vector<int>v3(5,100);
    PrintVector(v3);
}
*/
/*
void test02()
{
  vector<int>v1;
  for(int i=0;i<10;i++)
       v1.push_back(i);
        PrintVector(v1);

  //1.利用运算符重载vector operator=(const vector&v)
  vector<int>v2;
  v2=v1;
  PrintVector(v2);

  //2.利用assign(v.beign(),v.end())函数,左闭右开
  vector<int>v3;
  v3.assign(v1.begin(),v1.end());
  PrintVector(v3);

  //3.利用assign(n,elem)函数，赋值n个elem
  vector<int>v4;
  v4.assign(10,666);
  PrintVector(v4);
}
*/
/*
void test03()
{
    //empty()函数用来判断是否为空；capacity()函数用来得到容器的容量；size()函数用来得到容器的元素个数
    vector<int>v;
    for(int i=0;i<10;i++)
        v.push_back(i);
    PrintVector(v);
    if(v.empty())
    {
        cout<<"容器为空"<<endl;
    }
    else
    {
        cout<<"容器未空"<<endl;
        cout<<"容器的容量为："<<v.capacity()<<endl;
        cout<<"容器的元素个数为:"<<v.size()<<endl;
    }
  //resize(int n，int elem)调整容器的长度为n，并且如果容器变长，则将elem填充相应空位置（如果没有这个参数elem，就默认为0）；如果容器变短，则多余的元素被删除
  v.resize(2,2);
 cout<<"容器的容量为："<<v.capacity()<<endl;
 cout<<"容器的元素个数为:"<<v.size()<<endl;
 PrintVector(v);
}
*/
/*
void test04()
{
    vector<int>v;
    for(int i=0;i<10;i++)
    {
        v.push_back(i);//尾部添加元素
    }
    PrintVector(v);

    v.pop_back();//pop_back()函数用来去除最尾端的元素
    PrintVector(v);

    //insert(iterator,elem),在迭代器对应的位置插入元素elem
    v.insert(v.begin()+1,666);
    PrintVector(v);

    //insert(iterator,n,elem),在迭代器对应的位置插入n个元素elem
    v.insert(v.begin(),3,999);
    PrintVector(v);

    //erase(iterator)删除迭代器所指向的元素
    v.erase(v.begin()+4);
    PrintVector(v);

    //erase(iterator1,iterator2)删除从迭代器1到迭代器2之间的元素,区间左闭右开
    //v.erase(v.begin(),v.end());
    //上述表达式和v.clean()相同的效果
    v.clear();
    PrintVector(v);
}
*/
/*
void test05()
{
   vector<int>v;
   for(int i=0;i<10;i++)
        v.push_back(i);
   PrintVector(v);
   //1.利用at函数访问vector容器的数据
   for(int i=0;i<v.size();i++)
   {
       cout<<v.at(i)<<" ";
   }
   cout<<endl;

   //2.利用重载[]运算符访问vector容器的数据
   for(int i=0;i<v.size();i++)
    cout<<v[i]<<" ";
   cout<<endl;

   //3.front函数访问vector容器的第一个元素
   cout<<v.front()<<endl;

   //4.back函数访问vector容器的最后一个元素
   cout<<v.back()<<endl;
}
*/
/*
void test06()
{
    cout<<"交换前："<<endl;
    vector<int>v1;
    for(int i=0;i<10;i++)
        v1.push_back(i);
        PrintVector(v1);
    vector<int>v2(10,666);
    PrintVector(v2);
    cout<<"交换后："<<endl;
    v1.swap(v2);
    PrintVector(v1);
    PrintVector(v2);

    //利用匿名对象结合swap函数起到收缩内存空间的作用
    vector<int>(v1).swap(v1);
}
*/
/*
void test07()
{
    //reserve函数用来预留空间，为了减少vector在动态扩容的次数，并且预留的空间不能被访问
    vector<int>v;
    //v.reserve(100000);当不存在reserve函数是num值是18，当预留空间时num值为1
    int num=0;//扩展次数
    int *p=NULL;
    for(int i=0;i<100000;i++)
    {
        v.push_back(i);
        if(p!=&v[0])//因为每次vector动态扩容是重新找一块地址空间，不是在后添加，所以每次动态扩容，容器首元素的位置都会改变。
        {
            p=&v[0];
            num++;
        }
    }
    cout<<num<<endl;
}
*/
int main()
{
      //test01();
      //test02();
      //test03();
      //test04();
      //test05();
      //test06();
      //test07();
    return 0;
}

map

map的构造函数

    //其中map有两个值分别为key 和 value 并且map是关联型容器，会自动按照key的值进行排序，底层逻辑是二叉树。
    //map不允许key的值重复，但是multimap是允许key重复的
    //1.默认构造
    map<int,int>m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(5,50));
    m.insert(make_pair(4,40));
    printMap(m);

   //2.拷贝构造
   map<int,int>m2(m);
   printMap(m2);

map的赋值操作

直接重载运算符=

map<int,int> m1;
m1.insert(make_pair(1,10));
map<int,int>m2;
m2=m1;

map的大小获取和交换操作

   map<int,int> m;
   m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(5,50));
    m.insert(make_pair(4,40));
   map<int,int>m2;
   if(m2.empty())//判断m2是否为空
   m2=m;//赋值操作
   else
   {
       cout<<"m2非空"<<endl;
   }
   printMap(m2);
   cout<<"m2的大小为"<<m2.size()<<endl;//计算m2的大小

map的插入和删除操作

    //1.插入操作
    map<int,int>m;
    m.insert(pair<int,int>(1,10));
    m.insert(make_pair(2,20));
    m.insert(map<int,int>::value_type(3,30));
    m[4]=40;
    printMap(m);

    //删除操作
    m.erase(m.begin());
    printMap(m);

    m.erase(2);
    printMap(m);

    //m.erase(m.begin(),m.end());与下一句同义句
    m.clear();
    printMap(m);

map的排序

class Compare
{
public:
    bool operator()(int v1,int v2)
    {
        v1>v2;
    }
};

void test04()
{
    map<int,int,Compare> m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(4,50));
    m.insert(make_pair(5,50));
    //利用仿函数实现降序排序
    for(map<int,int,Compare>::iterator it=m.begin();it!=m.end();it++)
    {
        cout<<"key: "<<it->first<<" valur: "<<it->second<<endl;
    }
}

map的查找和统计

    map<int,int> m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(4,50));
    m.insert(make_pair(5,50));
    //find函数用来查找容器是否存在key的关键字，返回类型为迭代器类型
    map<int,int>::iterator pos=m.find(3);
    if(pos!=m.end())
        cout<<"找到值为"<<(*pos).second<<endl;
    else
        cout<<"没找到"<<endl;

    cout<<"key为6的个数为："<<m.count(6)<<endl;

map的实验代码

#include <iostream>
#include<map>
using namespace std;

void printMap(map<int,int>&m)
{
    for(map<int,int>::iterator it=m.begin();it!=m.end();it++)
    {
        cout<<"key: "<<it->first<<" value: "<<it->second<<endl;
    }
    cout<<endl;
}
/*
void test01()
{
    //其中map有两个值分别为key 和 value 并且map是关联型容器，会自动按照key的值进行排序，底层逻辑是二叉树。
    //map不允许key的值重复，但是multimap是允许key重复的
    //1.默认构造
    map<int,int>m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(5,50));
    m.insert(make_pair(4,40));
    printMap(m);

   //2.拷贝构造
   map<int,int>m2(m);
   printMap(m2);

}
*/
/*
void test02()
{
   map<int,int> m;
   m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(5,50));
    m.insert(make_pair(4,40));
   map<int,int>m2;
   if(m2.empty())//判断m2是否为空
   m2=m;//赋值操作
   else
   {
       cout<<"m2非空"<<endl;
   }
   printMap(m2);
   cout<<"m2的大小为"<<m2.size()<<endl;//计算m2的大小

}
*/
/*
void test03()
{
    //1.插入操作
    map<int,int>m;
    m.insert(pair<int,int>(1,10));
    m.insert(make_pair(2,20));
    m.insert(map<int,int>::value_type(3,30));
    m[4]=40;
    printMap(m);

    //删除操作
    m.erase(m.begin());
    printMap(m);

    m.erase(2);
    printMap(m);

    //m.erase(m.begin(),m.end());与下一句同义句
    m.clear();
    printMap(m);
}
*/
/*
class Compare
{
public:
    bool operator()(int v1,int v2)
    {
        v1>v2;
    }
};

void test04()
{
    map<int,int,Compare> m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(4,50));
    m.insert(make_pair(5,50));
    //利用仿函数实现降序排序
    for(map<int,int,Compare>::iterator it=m.begin();it!=m.end();it++)
    {
        cout<<"key: "<<it->first<<" valur: "<<it->second<<endl;
    }
}
*/
/*
void test05()
{
    map<int,int> m;
    m.insert(make_pair(1,10));
    m.insert(make_pair(2,20));
    m.insert(make_pair(3,30));
    m.insert(make_pair(4,50));
    m.insert(make_pair(5,50));
    //find函数用来查找容器是否存在key的关键字，返回类型为迭代器类型
    map<int,int>::iterator pos=m.find(3);
    if(pos!=m.end())
        cout<<"找到值为"<<(*pos).second<<endl;
    else
        cout<<"没找到"<<endl;

    cout<<"key为6的个数为："<<m.count(6)<<endl;
}
*/
int main()
{
    //test01();
    //test02();
    //test03();
    //test04();
    //test05();
    return 0;
}

常见的排序算法

sort

sort(迭代器1，迭代器2，谓词) 谓词可以不填，也可以填,默认升序

vector<int>v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
//降序排序
v.sort(v.begin(),v.end(),greater<int>());

喝个罐装

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
STL emm.....

关于STL的emmSTL的认识STL（Standard Template Library)，就是标准模板库。其中它包括六大部分：容器，算法，迭代器，仿函数，适配器（配接器），空间配置器。主要了解前四部分其中容器和算法需要用到迭代器来进行链接。容器用来容纳、包含相同类型元素的对象，主要用类模板实现其中分为两种类型的容器1.序类型容器容器中元素按照线形顺序结构组织起来，可以逐个读写元素。包括vector,deque,list2.关联型容器通过一定的关系进行组织，不受特定的物理条件束缚，
复制链接

扫一扫