C++学习笔记day4

目录

前言

一、序列容器

1.1 vector容器

1.2 list容器、deque(双端队列容器)

二、vector向量容器

2.1 增删改查

三、关联容器

3.1 set容器、map容器、multiset、multimap

3.2 stack(栈) queue(队列) prority_queue(优先级队列)

四、map容器

4.1 pair关联容器

4.2 map(增删改查)

五、迭代器

5.1 常用操作

5.2 遍历查找与删除

总结

---

 

---

前言

本篇总结了STL标准模板库 6大部分：容器、算法、迭代器、适配器、函数，对序列容器vector、关联容器map、迭代器指针进行了细致的探讨，对其原理、增删改查操作、特点及区别以及不同情况下的不同结果进行了论证，更好的认识STL标准模板库！！

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、序列容器

1.1 vector容器

头文件#include <vector>
功能：模拟了一个动态数组
底层实现：首先开辟一定大小的数组 随着元素的增加，如果空间不够之后 自动采取扩容机制 

扩容规则：以原空间大小的2倍重新开辟一块空间 将就空间的元素挪到新空间上 在继续添加元素，一直遵循每次扩容大小是原空间大小的2倍

函数接口：vector常用接口 vector<int> vec;由于vector底层是一个数组 所以其内存是连续的 可以采取下标访问方式 
  
   对于数组来说 尾插和尾删的时间复杂度为O(1)；对于在容器头部或者中部插入或删除元素，则花费时间要长一些（移动元素需要耗费时间），时间复杂度为线性阶O(n)。
vector初始化方式：vector<int> vec1;//默认方式初始化底层没有为其分配内存空间
                 vector<int> vec2(10);//指定了刚开始的容量为10，默认值为0
                 vector<int> primes {2,3,5,7,11,13,17,19};//含8个素数的 vector 容器
                 vector<int> vec3(10,20);//指定了开始的容量10和每个格子的默认值为20

vector常用操作：
 
v.capacity();  //容器容量                         
v.size();      //容器大小  

v.max_size():  //表返回vector最大容量                 
v.at(int idx); //用法和[]运算符相同               

v.push_back(); //尾部插入                         
v.pop_back();  //尾部删除

v.front();     //获取头部元素                     
v.back();      //获取尾部元素

v.begin();     //头元素的迭代器                   
v.end();       //尾部元素的迭代器

v.insert(pos,elem); //pos是vector的插入元素的位置
v.insert(pos, n, elem) //在位置pos上插入n个元素elem
v.insert(pos, begin, end);

v.erase(pos);   //移除pos位置上的元素，返回下一个数据的位置
v.erase(begin, end); //移除[begin, end)区间的数据，返回下一个元素的位置
reverse(pos1, pos2); //将vector中的pos1~pos2的元素逆序存储

1.2 list容器、deque(双端队列容器)

二、vector向量容器

2.1 增删改查

***************************示例1：容器的初始化方式***************************
#include <iostream>
#include <vector>//向量容器的头文件
using namespace std;

int main () 
{
    //1.默认方式初始化底层没有为其分配内存空间
    vector<int> v;
    //2.指定了刚开始的容量为10，默认值为0
    vector<int> v1(10);
    //输出容器中元素的值  v1.size()获取元素的个数
    for(int i =0;i<v1.size();i++)
    {
        //对[] 的重载函数
        cout<<v1[i]<<endl;
    }
    //3.指定了刚开始的容量为10，初始化2
    vector<int> v2(10,2);
    for(int i =0;i<v1.size();i++)
    {
        //对[] 的重载函数
        cout<<v2[i]<<endl;
    }
    //4.调用拷贝构造函数，用同类型已经存在的对象构造同类型的
    vector<int> v3(v2);

    //5.  CONFIG += c++11
    vector<int> v4 {1,2,3,4,5};
    for(int i =0;i<v4.size();i++)
    {
        //对[] 的重载函数
        cout<<v4[i]<<endl;
    }
   return 0;
}
***************************示例2：插入数据 push_back()***************************
#include <iostream>
#include <vector>
using namespace std;

int main()
{
    //1.创建容器
    vector<int> v;//保存整型数据

    //2.添加数据 模板类中的成员函数
    v.push_back(10);//尾插
    v.push_back(12);
    v.push_back(13);
    v.push_back(14);
    v.push_back(16);

	v[2] = 521;//修改对应角标位置的元素值 operator[] 函数的返回值是T&

    //3.获取 输出  v.size()获取元素的个数
    for(int i=0; i< v.size(); i++)
        cout<<v[i]<<" ";
    cout<<endl;

    return 0;
}
***************************示例2：插入数据 insert()***************************
int main()
{
   vector<int> v1;
   for(int i=0;i<10;i++)
        v1.push_back(i);

//向第二个元素位置 插入
   v1.insert(v1.begin()+1,100);
   cout<<v1.size()<<endl;

  for(int i=0;i<v1.size();i++)
      cout<<v1[i]<<endl;

//从开头位置 插入5个元素 521
  v1.insert(v1.begin(),5,521);

  for(int i=0;i<v1.size();i++)
      cout<<v1[i]<<endl;
    return 0;
}
***************************示例3：查找元素 []  at(pos)***************************
将100以内能整除2的值保存入容器中，并其中能整除3的值更改为0，输出最后的结果
一个循环中完成
int main () {

    vector<int> v;
    int j = 0;

    for(int i=0;i<=100;i++)
    {
        if(i%2 ==0)
        {
           v.push_back(i);//i=6  0
           //改0
           if(i%3 == 0)
           {
               v[j] = 0;
           }
           j++;
        }
    }

    for(int i=0;i<v.size();i++)
        cout<<v[i]<<endl;

   return 0;
}
方式2：
int main () {
    vector<int> v;
    for(int i=0;i<=100;i++)
    {
        if(i%2 ==0)
        {
            if(i%3 == 0)
                v.push_back(0);
            else
                v.push_back(i);
        }
    }
    for(int i=0;i<v.size();i++)
        cout<<v[i]<<endl;

   return 0;
}
***************************示例4：***************************
int main()
{
   vector<int> v1;
   for(int i=0;i<10;i++)
        v1.push_back(i);

   //获取头部元素
   cout<<v1.front()<<endl;
   //获取尾部元素
   cout<<v1.back()<<endl;
   //尾部删除
   v1.pop_back();

  for(int i=0;i<v1.size();i++)
      cout<<v1[i]<<endl;
    return 0;
}

三、关联容器

红黑树的特性(了解):
（1）每个节点或者是黑色，或者是红色。
（2）根节点是黑色。
（3）如果一个节点是红色的，则它的子节点必须是黑色的。
（4）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。[这里指到叶子节点的路径]

 

红黑树的优势：平衡查找二叉树
1.失掉了一部分平衡（保证在二倍以内即可）
2.比普通平衡查找二叉树，插入结点时，尽量在3次旋转内，插入到正确的位置，效率高，速度快
插入和删除的时间复杂度：logn

容器类自动申请和释放内存，无需new和delete操作。
map<key, value> 通过关联容器保存数据，以键值对key-value形式存放数据  红黑树

map是存放pair的容器，根据pair中的first进行红黑树的排序。
first在map中又叫key，second又叫value。

Map是键-值对的集合，map中的所有元素都是pair，可以使用键作为下标来获取一个值。
Map中所有元素都会根据元素的键 （key）自动被排序，同时拥有实值value和键值key，
pair的第一元素被视为键值，第二元素被视为实值，同时map不允许两个元素有相同的键值。

3.1 set容器、map容器、multiset、multimap

声明及其初始化：pair<T1, T2>  pair也是一种模板类型。键(key)值(value)对它的数据成员是公有的，分别命名为first和second。

map<key, value> m;//创建一个名为m的空map对象，其键和值的类型分别为key和value。 
map<key, value> m(m2);//创建m2的副本m，m与m2必须有相同的键类型和值类型。

**********************************示例1：pair关联容器******************************
#include <iostream>
#include <string>
#include <map>

using namespace std;
int main()
{
	pair<string, int> p("hehe", 10);
	cout<<p.first<<" "<<p.second<<endl;
}


插入和查询操作：插入数据，给map容器添加元素可通过两种方式实现：

1、通过insert成员函数实现。通过下标操作符获取元素，然后给获取的元素赋值。 

2、map的下标是键，返回的是特定键所关联的值。使用迭代器访问，iter->first指向元素的键，iter->second指向键对应的值。 

注意：插入数据  不允许键重复，如果键重复无法插入m.insert(e) ;e是一个用在m上的value_type类型的值。如果键e.first不在m中，则插入一个值为e.second的新元素；如果该键在m中已存在，那么不进行任何操作。 
**********************************示例代码**********************************
#include <iostream>
#include <string>
#include <map>

using namespace std;

int main()
{
	map<string, int> m;
	m.insert(pair<string, int>("小明",18)); 
    m.insert(pair<string, int>("jack", 18));
    m.insert(pair<string, int>("rose", 1));
    m.insert(pair<string, int>("tom", 2));
    m.insert(pair<string, int>("jerry", 3));

map<string, int>::iterator it;
    for(it=mapst.begin();it!=mapst.end();it++)
    cout<<it->first<<" "<<it->second<<endl;
}
示例代码2：用数组方式插入
int main(){
    map<int,string> mapst;
    mapst[1]="student1";
    mapst[2]="student2";
    mapst[3]="student3";
    map<int,string> ::iterator it;
    for(it=mapst.begin();it!=mapst.end();it++)
    cout<<it->first<<" "<<it->second<<endl;
} 

问题：使用下标访问map容器与使用下标访问vector的不同？
用下标访问map中不存在的元素将导致在map容器中添加一个新的元素，这个元素的键即为该下标值，键所对应的值为空。
**********************************示例代码：插入重复********************************
（一）
int main(){
    map<int,string> mapst;
    mapst.insert(pair<int,string>(1,"student1"));
    mapst.insert(pair<int,string>(1,"student2"));
   
    map<int,string>::iterator it;
    for(it=mapst.begin();it!=mapst.end();it++)
    cout<<it->first<<" "<<it->second<<endl;
}
（二）
#include<map>
#include<algorithm>
#include<iostream>
using namespace std;
int main(){
    map<int,string> mapst;
    mapst[1]="student1";
    mapst[1]="student2";
    mapst[2]="student3";
    map<int,string>::iterator it;
    for(it=mapst.begin();it!=mapst.end();it++)
    	cout<<it->first<<" "<<it->second<<endl;
    return 0;
}

运行结果
1 student2
2 student3

insert：key重复，不进行插入
数组[]:key存在的，那么修改value值
      key不存在，新建数据，新：key--》“cc” value-->值

3.2 stack(栈) queue(队列) prority_queue(优先级队列)

四、map容器

4.1 pair关联容器

************************************示例代码：************************************
#include <iostream>
#include <map>
using namespace std;

int main()
{
	map<string, int> m;
//	m.insert(pair<string, int>("小明",18));
	m.insert(pair<string, int>("rose", 1));
    m.insert(pair<string, int>("tom", 2));
    m.insert(pair<string, int>("jerry", 3));
	
	for(map<string, int>::iterator iter = m.begin();iter != m.end();iter++)
	{
		cout<<iter->first<<" "<<iter->second<<endl;
	}
}
（2）数组形式
#include<map>
#include<string>
#include<algorithm>
#include<iostream>
using namespace std;
int main(){
    map<int,string> mapst;
    mapst.insert(pair<int,string>(1,"student1"));
    mapst.insert(pair<int,string>(2,"student2"));
    mapst.insert(pair<int,string>(3,"student3"));
    int nsize=mapst.size();
    //此处应注意，应该是 for(int i = 1; i <= nsize; i++)  
    //而不是 for(int i = 0; i < nsize; i++)  key为0的不存在
    for(int i=1;i<=nsize;i++)
    	cout<<mapst[i]<<endl;
    return 0;
}

运行结果：
student1
student2
student3

************************************示例代码：************************************
#include<map>
#include<string>
#include<algorithm>
#include<iostream>
using namespace std;
int main(){
    map<int,string> mapst;
    mapst.insert(pair<int,string>(1,"student1"));
    mapst.insert(pair<int,string>(2,"student2"));
    mapst.insert(pair<int,string>(3,"student3"));

    int nsize=mapst.size();//3

    //下标 mapst[key]  -->对应的value
    for(int i=1;i<=nsize;i++)
        cout<<mapst[i]<<endl;//i-->key


    mapst[10] = "helllo";//新建数据
    cout<<mapst[10]<<endl;//"helllo"

    cout<<mapst[12]<<endl;//空  值  新建
    for(map<int,string>::iterator iter = mapst.begin();iter != mapst.end();iter++)
    {
        cout<<iter->first<<" "<<iter->second<<endl;
    }
    //5条
    mapst[12] = "helllo333333";//修改数据
    for(map<int,string>::iterator iter = mapst.begin();iter != mapst.end();iter++)
    {
        cout<<iter->first<<" "<<iter->second<<endl;
    }

    return 0;
}

示例：查找 并获取map中的元素（包括判定这个关键字是否在map中出现）可以通过[]进行查找
#include <iostream>
#include <string>
#include <map>
using namespace std;

int main()
{
	map<string, int> m;
	//关联容器的形式
	m.insert(pair<string, int>("小明",18));
	//通过[]形式
	m["小强"] = 20;

}
（二）用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置,由于map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的情况，返回1了

例：count("小明")函数，0表示没有该key，1表示有而且数量就是1

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

int main(){

	map<string, int> m;
	//关联容器的形式
	m.insert(pair<string, int>("小明",18));
	cout<<m.count("小明")<<endl;//1
	cout<<m.count("小红")<<endl;//0
}

注意：是否会新建对象：     
			m["aaa"] = 6;//新建 key:aaa  value:6  
			cout<< m["bbb"]<<endl;  // 新建 key:bbb   value: 0 
			cout<< m.count("bbb")<<endl;//有 1 不新建 
			

示例：find()函数进行查找，find返回该key的迭代器对象
用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器。

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

int main(){
	
	map<string, int> m;
	//关联容器的形式
	m.insert(pair<string, int>("小明",18));
	
	map<string, int>::iterator iter = m.find("小红");//find返回该key的迭代器对象
	if(iter != m.end())
	{
		cout<<iter->first<<" "<<iter->second<<endl;
	}
	else
	{
		cout<<"查无此项"<<endl;
	}
}
通过map对象的方法获取的iterator数据类型是一个std::pair对象，包括两个数据 iterator->first和 iterator->second分别代表关键字和存储的数据。

************************************示例：删除 ************************************
iterator erase（iterator it);//通过一个条目对象删除
iterator erase（iterator first，iterator last）//删除一个范围
size_type erase(const Key&key);//通过关键字删除
clear()就相当于enumMap.erase(enumMap.begin(),enumMap.end());
（一）从m中删除key为k的元素   m.erase(k)   
int main()
{
    pair<string,int> p("aa",12);

    map<string,int> m;
    m.insert(pair<string,int>("xiao",16));
    m.insert(pair<string, int>("jack", 18));
  
     m["aaa"] = 6;//

   cout<<m["bbb"]<<endl;//
   
   //删除key值为aaa的元素
   m.erase("aaa");

     for(map<string,int>::iterator iter = m.begin();iter != m.end();iter++)
     {
         cout<<iter->first<<" "<<iter->second<<endl;
     }

    return 0;
}
（二）删除  从m中删除迭代器p指定的元素  m.erase(p)  
int main()
{
    pair<string,int> p("aa",12);

    map<string,int> m;
    m.insert(pair<string,int>("xiao",16));
    m.insert(pair<string, int>("jack", 18));
     m.insert(pair<string, int>("rose", 1));
     m.insert(pair<string, int>("tom", 2));
     m.insert(pair<string, int>("jerry", 3));

     m["aaa"] = 6;

   map<string,int>::iterator iter = m.find("tom");
   
   //通过迭代器删除
   m.erase(iter);

     for(map<string,int>::iterator iter = m.begin();iter != m.end();iter++ )
     {
         cout<<iter->first<<" "<<iter->second<<endl;
     }

    return 0;
}

4.2 map(增删改查)

1.底层原理：红黑树
2.map如何保存元素的？  键值对的方式存储
3.一个键值对是什么？  pair关联容器
4.如何获取 键值对中的值？ key -->p.first  value  --> p.second
5.map容器和pair（键值对）关系？ map中可以存储 很多的键值对
6.关联容器特点：自动排序（默认升序）

7.map容器的特点：
1.键值对方式存储数据，并且按照key自动升序
2.插入的元素，key不可以重复
3.通过key  去查找 value cout<<m[key]<<endl; 得到 key对应的value值

8.插入元素的方式有两种：
1）insert插入：1.数据类型：pair         2.插入元素key重复时，插入无效
2）[]数组方式插入：1. m[key] = value;   2.插入元素key重复时，修改之前的数据
                  3.输出按照key去查找value时，key存在：输出value  key不存在：新建数据
9.查找元素两种方法：
1.count(key)  不会新建数据  返回值 计数 0:不存在 1：存在
2.find(key)   返回值：如果key对应元素存在 --》迭代器指针  不存在 --》返回指针指向end位置

10.删除元素 两种方式： 1.按照key删除    2.按照迭代器指针删除
***********************************************************************************
#include <iostream>
using namespace std;
#include <map>

int main()
{
    //模板类型：key --> value  键值对 pair关联容器
    //   key   value
    pair<int,string> p(1,"tom");
    //      key:1       second:tom
    //cout<<p.first<<" "<<p.second<<endl;

    map<int,string> m;//插入 键值对（pair关联容器）
    m.insert(/*键值对pair*/pair<int,string>(2,"rose"));
    m.insert(p);

    //[]插入数据： m[key] = value;
    m[13] = "jack";
    m[4] = "lucy";
    m[4] = "haha";

    //cout<<"m[4]: "<<m[4]<<endl; //haha
    //[]形式时：key存在 --》value  key不存在--》新建数据 key:14 value:int:0 string:""
   // cout<<"m[14]: "<<m[14]<<endl; //啥也没有 string

    //查找元素 1.count(key)  不新建数据  计数 0:不存在 1：存在
    cout<<m.count(40)<<endl;

    //查找元素 2.find(key) 返回值：迭代器指针
   map<int,string>::iterator it  = m.find(4);
   if(it != m.end())
        cout<<"find:"<<it->first<<" "<<it->second<<endl;

   //两种方式： 1.按照key删除    2.按照迭代器指针删除
   m.erase(4);
   map<int,string>::iterator it1  = m.find(2);
   if(it1 != m.end())
   {
       m.erase(it1);
   }

    //迭代器遍历，输出所有的元素
    map<int,string>::iterator iter;
    for(iter=m.begin();iter!=m.end();iter++)
    {
        //*iter --> 键值对 pair关联容器
        //          key                 value
        cout<<(*iter).first<<" "<<iter->second<<endl;
    }
    return 0;
}

五、迭代器

迭代器：一种检查容器内元素并遍历元素的数据类型。C++更趋向于使用迭代器而不是下标操作，因为标准库为每一种标准容器（如vector）定义了一种迭代器类型，而只用少数容器（如vector）支持下标操作访问容器元素。C++中的迭代器是对指针的封装，迭代器提供特定的函数让调用者对指针进行特定的安全的操作

定义和初始化：每种容器都定义了自己的迭代器类型，如vector:
vector<int>::iterator    iter;    //定义一个名为iter的变量

每种容器都定义了一对名为begin和end的函数，用于返回迭代器。
迭代器初始化操作：
vector<int>    ivec;      //将迭代器iter1初始化为指向ivec容器的第一个元素
vector<int>::iterator iter1=ivec.begin();  

vector<int>::iterator   iter2=ivec.end();//初始化指向ivec容器的最后一个元素的下一个位置   

注意：end并不指向容器的任何元素，而是指向容器的最后元素的下一位置，称为超出末端迭代器。
如果vector为空，则begin返回的迭代器和end返回的迭代器相同。
一旦向上面这样定义和初始化，就相当于把该迭代器和容器进行了某种关联，就像把一个指针初始化为指向某一空间地址一样。

示例：使用迭代器输出容器中的元素
 vector<int>::iterator iter;
   //for(int i = 0;  i< 10; i++)
   //begin是容器的头元素 ，end并不是尾元素，而是无效的元素表示容器结束
   for(iter = v.begin(); iter != v.end(); iter++)
   {
       cout<<*iter<<" ";
   }
   cout<<endl;

5.1 常用操作

常用操作：
*iter       //对iter进行解引用，返回迭代器iter指向的元素的引用
iter->men //对iter进行解引用，获取指定元素中名为men的成员。等效于(*iter).men
++iter     //给iter加1，使其指向容器的下一个元素
iter++
--iter     //给iter减1，使其指向容器的前一个元素
iter--
iter1==iter2  //比较两个迭代器是否相等，当它们指向同一个容器的同一个元素或者都指向同一个容器	的超出末端的下一个位置时，它们相等 
iter1!=iter2    

5.2 遍历查找与删除

#include <iostream>
#include <vector>//向量容器的头文件
using namespace std;
//参数：容器类型
vector<int>&  fun(vector<int>& v1)//拷贝  同一个
{
    //将容器第一个元素值改成 100
    v1[0] = 100;
    return v1;
}
//迭代器iterator(工具)遍历：对指针的封装
int main ()
{
    vector<int> v;
    for(int i=0;i<10;i++)
    {
        v.push_back(i);//0~9
    }
    fun(v);
    //v容器的迭代器
    //类型                变量名
  //  vector<int>::iterator  iter;
    //遍历  头             不到尾i<10      偏移
    for(vector<int>::iterator  iter=v.begin(); iter != v.end();iter++)
    {
//        if(*iter %2 == 0)
//        {
//            *iter = 0;
//        }
        cout<<*iter<<endl;//*iter 元素的值
    }

   return 0;
}

******************************示例：迭代器遍历删除******************************
示例：删除方法 v.erase(iter);
v.erase(pos);   //移除pos位置上的元素，返回下一个数据的位置
v.erase(begin, end); //移除[begin, end)区间的数据，返回下一个元素的位置
注意：迭代器所指向的对象被删除后，迭代器就无效了，
		erase函数会返回一个新的迭代器，指向删除元素的下一个元素
int main()
{
   vector<int> v1;
   for(int i=0;i<10;i++)
        v1.push_back(i);

   vector<int>::iterator iter = v1.begin()+1;
   //v1.erase(iter);
   v1.erase(v1.begin()+1,v1.end()); //移除[begin, end)区间的数据

  for(int i=0;i<v1.size();i++)
      cout<<v1[i]<<endl;
    return 0;
}

1）加入头文件 #include <algorithm>
2）查找方法为：vector<int>::iterator iter = find(v.begin(), v.end(), 3);
3）注意：find方法只能删除找到的第一个元素

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

int main()
{
    vector<int> v;
    for(int i = 0;i < 10;i++)
    {
        v.push_back(i);
    }
    vector<int>::iterator iter = find(v.begin(), v.end(), 3);
    v.erase(iter);
    
    for(vector<int>::iterator iter = v.begin();iter != v.end();iter++)
    {
        cout<<*iter<<endl;
    }
    return 0;
}

******************************示例：容器添加自定义类型:******************************
#include <iostream>
#include <vector>
#include <algorithm>//算法头文件
using namespace std;
class Person
{
    int age;
public:
    Person(int age):age(age){}
    void show(){cout<<age<<endl;}
};
int main()
{
    //自定义类型的容器
    vector<Person> v;
    //添加元素:3种方式
    Person p(1);
    //1.将对象装进容器
    v.push_back(p);

    Person p1(2);
    v.push_back(p1);

    //2.将匿名对象装进容器
    v.push_back(Person(3));
    //3.利用隐士转换方式 将对象装进容器
    v.push_back(4);
	
    for(int i=0 ; i< v.size(); i++)
        v[i].show();//v[i]-->pesron对象

    //迭代器遍历 调用show方法
    vector<Person>::iterator iter;
    for(iter=v.begin(); iter!=v.end(); iter++)
    {
        iter->show();//(*iter).show();
    }
    return 0;
}
*****************************示例：查找迭代器删除自定义类型***************************
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class Person
{
    int age;
public:
    Person(int a):age(a){}
    void show(){cout<<age<<endl;}
    bool operator ==(const Person& other) 
    {
        if(this->age == other.age)
            return true;
        else
            return false;
    }
};
int main()
{
    vector<Person> v;
    Person p(10);
    v.push_back(p);//Person(10)
    v.push_back(Person(20));
    v.push_back(Person(30));
   vector<Person>::iterator it = find(v.begin(),v.end(),Person(20));
    if(it != v.end())
    {
        it->show();
    }else
        cout<<"not"<<endl;

    for(vector<Person>::iterator iter = v.begin();iter != v.end(); iter++)
    {
        (*iter).show();//iter->show();
    }
}

总结

总结了STL标准模板库 6大部分：容器、算法、迭代器、适配器、函数，对序列容器vector、关联容器map、迭代器指针进行了细致的探讨，对其原理、增删改查操作、特点及区别以及不同情况下的不同结果进行了论证，更好的认识STL标准模板库！！