STL之vector,数组线性容器array,list容器，算法find,find_if,bind1st,仿函数



1.STL(Standard Template Library,是用泛型技术来设计完成的实例)的概念与组成

Iterator(迭代器)

Container(容器)

Algorithm(算法)

Adaptors(配接器)

 

STL的六大组件分别是：

容器（Container）

算法（Algorithm）

迭代器（Iterator）

仿函数（Function object）

适配器（Adapter）

空间配置器（allocator）:只能分配内存等

 

2.容器与算法

案例如下：

#include<iostream>

#include<vector>//容器

#include<array>//数组

#include<algorithm>

 

usingnamespacestd;

 

//实现一个模板类，专门实现打印的功能

template<classT> //类模板实现了方法

classmyvectorprint

{

public:

   void operator ()(constT &t)//重载，使用(),打印

   {

       std::cout << t <<std::endl;

   }

};

 

voidmain()

{

   vector<int> myvector;

   myvector.push_back(11);

   myvector.push_back(21);

   myvector.push_back(31);

   myvector.push_back(81);

   myvector.push_back(51);

 

   array<int, 10> myarray = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

 

   myvectorprint<int>print;//对于打印进行实例化

 

   //begin,endl迭代器，是一个指针

   for_each(myvector.begin(),myvector.end(),print);

   

   std::cout << "---------------------" <<std::endl;

 

   for_each(myarray.begin(),myarray.end(),print);

   cin.get();

   //算法可以适用于任何一个容器，for_each是一个算法

}

 

3.容器

序列式容器（Sequence containers）

每个元素都有固定位置----取决于插入实际和地点，和元素之无关

Vector,deque,list

关联式容器（Associated containers）

元素位置取决于特定的排序准则，和插入顺序无关

set、multiset、map、multimap

4.vectors:

将元素置于一个动态数组中加以管理

可以随机存取元素（用索引直接存取）

数组尾部添加或移除元素非常快速，但是在中部或头部安插元素比较费时。

5.数组线程容器

#include<iostream>

#include<vector>

#include<array>

#include<tuple>

 

usingnamespacestd;

 

voidmain()

{

   //数组，静态数组，栈上

   array<int, 5> myarray = { 1, 2, 3, 4, 5 };

   

   //动态数组，堆上

   vector <int>myvector;

   myvector.push_back(1);

 

   //不需要变长，容量较小时，使用array

   //不需要变长，容量较大是，使用vector

}

6.list容器（添加和迭代输出）

#include<iostream>

#include<hash_set>

#include<list>   //实际上是一个双向链表

#include<stdio.h>

 

//list使用于经常插入，经常删除

 

usingnamespacestd;

 

voidmain()

{

   list<int>mylist;

 

   mylist.push_back(1);

   mylist.push_back(2);

   mylist.push_back(3);

   mylist.push_back(4);

   mylist.push_front(4);//往头部插入

 

   //指针，指向一个迭代器，迭代器存储了位置

   autoibegin =mylist.begin();

   autoiend =mylist.end();

   //list用迭代器进行遍历

   for (;ibegin !=iend;ibegin++)

   {

       cout << *ibegin <<endl;

       printf("%p,&p\n",ibegin._Ptr,ibegin);//重载

   }

   cin.get();

}

运行结果是：

7.list删除应该注意的地方

#include<iostream>

#include<hash_set>

#include<list>   //实际上是一个双向链表

#include<stdio.h>

 

//list使用于经常插入，经常删除

 

usingnamespacestd;

 

voidmain()

{

   list<int>mylist;

   mylist.push_back(1);

   mylist.push_back(2);

   mylist.push_back(3);

   mylist.push_back(4);

   mylist.push_back(5);

   //auto i = mylist.begin();删除元素，依赖于迭代器

   //++i

   //++i

   //++i

   autoi =mylist.end();//end最后一个没有实体

   i--;

   mylist.erase(i);//链式存储，不允许下标访问

   //只能用迭代器，链表迭代器只能用++，--

   //mylist.clear();清空

   //指针，指向一个迭代器，迭代器存储了位置

   autoibegin =mylist.begin();

   autoiend =mylist.end();

   for (;ibegin !=iend;ibegin++)

   {

       if ((*ibegin) == 3)

       {

           mylist.erase(ibegin);//删除，删除的时候迭代器会发生

           break;//这里一定要记住，要使用break;因为list原来的结构已经发生了变化

       }

       //cout <<*ibegin << endl;

   }

   {

       //指针，指向一个迭代器，迭代器存储了位置

       autoibegin =mylist.begin();

       autoiend =mylist.end();

 

       for (;ibegin !=iend;ibegin++)

       {

           cout << *ibegin <<endl;

       }

   }

   cin.get();

}

运行结果：

8.通过数组的方式为list初始化

#include<iostream>

#include<hash_set>

#include<list>   //实际上是一个双向链表

#include<stdio.h>

 

//list使用于经常插入，经常删除

 

usingnamespacestd;

 

voidmain()

{

   inta[5] = { 1, 2, 3, 4, 5 };

   list<int>mylist(a,a + 5);//根据数组初始化

   //传递开始地址，传递结束地址

   //mylist(0)

   //mylist[1];只能用迭代器访问

   mylist.push_back(10);

   mylist.push_front(12);//在前添加数值

   //指针，指向一个迭代器，迭代器存储了位置

   autoibegin =mylist.begin();

   autoiend =mylist.end();

 

   for (;ibegin !=iend;ibegin++)

   {

       if (*ibegin == 3)

       {

           mylist.insert(ibegin, 30);

           break;//删除或者插入，迭代器都会发生变化

       }

   }

 

   mylist.remove(30);//直接一个函数，根据元素来删除

 

   {

       autoibegin =mylist.begin();//指针，指向一个迭代器，迭代器存储了位置

       autoiend =mylist.end();

 

       for (;ibegin !=iend;ibegin++)

       {

           cout << *ibegin <<endl;

       }

   }

   cin.get();

}

运行结果：

9.数组初始化，并逆向输出

#include<iostream>

#include<hash_set>

#include<list>   //实际上是一个双向链表

#include<stdio.h>

 

//list使用于经常插入，经常删除

 

usingnamespacestd;

 

voidmain()

{

   inta[5] = { 1, 2, 3, 4, 5 };

   list<int>mylist(a,a + 5);//根据数组初始化

   autorb =mylist.rbegin();

   autore =mylist.rend();

   //同时正向方向查找

   for (;rb !=re;rb++)

   {

       cout << *rb <<endl;

   }

   cin.get();

}

运行结果：

10.list合并，排序

#include<iostream>

#include<hash_set>

#include<list>   //实际上是一个双向链表

#include<stdio.h>

 

//list使用于经常插入，经常删除

 

usingnamespacestd;

 

voidmain()

{

   inta[5] = { 1, 2, 3, 104, 5 };

   list<int > mylist1(a,a + 5);//根据数组初始化，

   intb[5] = { 11, 122, 33, 44, 55 };

   list<int > mylist2(b,b + 5);//根据数组初始化，

   mylist1.sort();

   mylist2.sort();//两个list合并到list之前需要数组排序

 

   mylist1.merge(mylist2);//合并之前必须有序

 

   {

       autoibegin =mylist1.begin();//指针，指向一个迭代器，迭代器存储了位置

       autoiend =mylist1.end();

 

       for (;ibegin !=iend;ibegin++)

       {

           cout << *ibegin <<endl;

       }

   }

   cout <<"\n\n\n";

   {

       autoibegin =mylist2.begin();//指针，指向一个迭代器，迭代器存储了位置

       autoiend =mylist2.end();

 

       for (;ibegin !=iend;ibegin++)

       {

           cout << *ibegin <<endl;

       }

   }

   cin.get();

}

运行结果：

11.list中通过unique()方法去掉重复的元素

#include<iostream>

#include<hash_set>

#include<list>   //实际上是一个双向链表

#include<stdio.h>

 

//list使用于经常插入，经常删除

 

usingnamespacestd;

 

voidmain()

{

   inta[6] = { 1, 2, 98, 2, 5, 98 };

   list<int>mylist1(a,a + 6);//根据数组初始化

   {

       autoibegin =mylist1.begin();

       autoiend =mylist1.end();

       for (;ibegin !=iend;ibegin++)

       {

           cout << *ibegin <<endl;

       }

   }

   mylist1.sort();

   mylist1.unique();//唯一依赖于排序,通过这个方法实现了去掉重复的

   cout <<"\n\n\n";

   {

       //指针，指向一个迭代器，迭代器存储了位置

       autoibegin =mylist1.begin();

       autoiend =mylist1.end();

 

       for (;ibegin !=iend;ibegin++)

       {

           cout << *ibegin <<endl;

       }

   }

   cin.get();

}

运行结果：

list迭代输出

#include<iostream>

#include<set>

#include<stdio.h>

#include<list>

#include<vector>

#include<algorithm>

#include<functional>

 

usingnamespacestd;

voidmain()

{

   list<int>mylist;

 

   mylist.push_back(1);

   mylist.push_back(2);

   mylist.push_back(3);

   mylist.push_back(4);

   //mylist[1];

   autoibegin =mylist.begin();//指针，指向一个迭代器，迭代器存储了位置

   autoiend =mylist.end();

   //list用迭代器进行遍历

   for (;ibegin !=iend;ibegin++)

   {

       cout << *ibegin <<endl;

       printf("%p,%p\n",ibegin._Ptr,ibegin);//重载

   }

 

   cin.get();

}

运行结果：

12算法find

#include<algorithm>

#include<iostream>

usingnamespacestd;

 

structprint

{

   void operator()(intx)//重载了()符号，直接调用()

   {

       std::cout << x <<endl;

   }

};

 

voidprintA(intx)

{

   std::cout << x <<endl;

}

 

//find这个算法

voidmain()

{

   inta[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

   int *p =find(a,a + 10, 8);

   std::cout << (void*)a << (void*)(a + 10) << std::endl;

   std::cout << *p <<endl;

   std::cout << p <<endl;

   if (p == (a + 10))

   {

       std::cout << "没有找到\n";

   }

   //下面的方式是调用重载的print函数

   for_each(a,a + 10,print());//遍历每一个元素

   //printA是一个函数指针，必须是函数类型

   std::cout << "-------------------------" <<std::endl;

   for_each(a,a + 10,printA);

 

   cin.get();

}

运行结果：

13.find_if,bind1st,仿函数

#include<iostream>

#include<set>

#include<stdio.h>

#include<list>

#include<vector>

#include<algorithm>  //find_if的头文件

#include<functional> //仿函数需要这里

usingnamespacestd;

 

boolless3(intx)

{

   returnx < 3;

}

 

voidmain()

{

   vector<int>mylist;

   mylist.push_back(1);

   mylist.push_back(2);

   mylist.push_back(16);

   mylist.push_back(17);

   mylist.push_back(18);

 

   autoib =mylist.begin();

   autoie =mylist.end();

   for (;ib !=ie;ib++)

   {

       std::cout << *ib <<std::endl;

   }

   //防函数可以实现一定的算法策略

   //bind1st表示要绑定一个函数

   //绑定一个函数，greater<int>(),3，表示比三大的数

   //查找第一个比3大的数值,下面的代码的意思是找到第一个3比取出的数值大的数的位置

   autoifind =find_if(++mylist.begin(),mylist.end(),bind1st(greater<int>(), 3));

   std::cout << "\n\n\n\n" << *ifind << endl;

 

   std::cout << "---------------------" <<std::endl;

   autoifind2 =find_if(mylist.begin(),mylist.end(),less3);

   std::cout << "\n\n\n\n" << *ifind << endl;

 

   cin.get();

}