stl

#include "stdafx.h"
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
 vector<int> coll;
 vector<int>::iterator pos;
 coll.push_back(2);
 coll.push_back(5);
 coll.push_back(4);
 coll.push_back(1);
 coll.push_back(6);
 coll.push_back(3);

 pos = min_element(coll.begin(),coll.end());
 cout <<"min:"<<*pos<<endl;
 pos = max_element(coll.begin(),coll.end());
 cout<<"Max:"<<*pos<<endl;
 sort(coll.begin(),coll.end());

 pos = find(coll.begin(),coll.end(),3);
    reverse(pos,coll.end());
 for(pos=coll.begin();pos!=coll.end();++pos)
 {
  cout<<*pos<<' '<<endl;

 }
} 

为了调用算法必须含有头文件<algorithm>;

算法。 min_element,max_element,sort,find,在整个容器中寻找第一个数值为3的元素。reverse(pos,coll.end()),从pos位置开始反转。

#include "stdafx.h"
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
#include <deque>
using namespace std;

int main(int argc, char* argv[])
{
 list<int> coll1;
 vector<int> coll2;
 for (int i=1;i<=9;i++)
 {
  coll1.push_back(i);
 }
 coll2.resize(coll1.size());

 copy(coll1.begin(),coll1.end(),coll2.begin());
 for (int j=0;j<9;j++)
 {
  cout<<coll2[j]<<endl;
 }

 deque<int> coll3(coll1.size());
 copy(coll1.begin(),coll1.end(),coll3.begin());
    for (int m=0;m<9;m++)
 {
  cout<<coll3[m]<<endl;
 }
} 

 使用copy将第一个区间内的全部元素拷贝到目标区间。第一个区间的起点和终点都几经指定。第二区间只指出起点。然而由于该算法执行的是覆写动作。而非安插动作。所以目标区间必须拥有足够的元素来被覆写。所以幺么确认目标区间内有足够的元素空间。要么采用insert iterators，要想让目标区间够大。你要不一开始就给它一个正确大小，要不就显式地改变其大小。这两个办法都只适用于序列容器（dequues,lists,vectors）,关联式容器根本不会有此问题。因为关联式容器不可能被当作复写算法的操作目标。

#include "stdafx.h"
#include <string>
#include <vector>
#include <list>
#include <algorithm>
#include <iostream>
#include <deque>
#include <set>
using namespace std;
int main(int argc, char* argv[])
{
 list<int> coll1;
 for (int i=1;i<=9;i++)
 {
  coll1.push_back(i);
 }
 vector<int>coll2;
 copy(coll1.begin(),coll1.end(),back_inserter(coll2));
 for (i=0;i<9;i++)
 {
  cout<<coll2[i]<<endl;
 }
 deque<int> coll3;
 copy(coll1.begin(),coll1.end(),front_inserter(coll3));
    for (i=0;i<9;i++)
 {
  cout<<coll3[i]<<endl;
 }
 set<int> coll4;
 set<int>::iterator pos;
 copy(coll1.begin(),coll1.end(),inserter(coll4,coll4.begin()));
 for (pos=coll4.begin();pos!=coll4.end();pos++)
 {
  cout<<*pos<<endl;
 }
} 

back_inserter安插于容器最尾端。front_inserter安插于容器最前端。

inserters一般性安插器。将元素插入初始化时接受之第二参数。所指位置的前方。

int main(int argc, char* argv[])
{

 list<int> col1;
 for (int i=1;i<=6;++i)
 {
  col1.push_front(i);
  col1.push_back(i);
 }
 copy(col1.begin(),col1.end(),ostream_iterator<int>(cout," "));
 cout<<endl;
 list<int>::iterator end = remove(col1.begin(),col1.end(),3);
 copy(col1.begin(),end,ostream_iterator<int>(cout," "));
 cout<<endl;

cout<<"num of removed elements:"<<distance(end,coll.end())<<endl;
 col1.erase(end,col1.end());
 copy(col1.begin(),col1.end(),ostream_iterator<int>(cout," "));
 cout<<endl;
} 

在这个版本中。remove的返回值被设定给end迭代器。这个end正是被修改之群集经过元素移除操作后逻辑上的新终点。另一种可能用法是。通过测定群集之逻辑终点和实际终点间的距离。获得被删除元素的数量。cout<<"num of removed elements:"<<distance(end,col1.end())<<endl;在这里distance的作用是返回两个迭代器之间的距离。erase用来真正的删除参数所指的区间内的全部元素。

int main(int argc, char* argv[])
{
 set<int> col1;
 for (int i=1;i<=9;++i)
 {
     col1.insert(i);
 }
 copy(col1.begin(),col1.end(),ostream_iterator<int>(cout," "));
 cout<<endl;
 int num = col1.erase(3);
 cout<<"num of removed element:"<<num<<endl;
 copy(col1.begin(),col1.end(),ostream_iterator<int>(cout," "));
 cout<<endl;
} 

容器类别提供了多个不同的erase成员函数。其中一种形式是以待删除之元素值为唯一参数。它会返回被删除的元素个数。当然在禁止元素重复的容器中（sets,maps），其返回值永远只能是0或1.

void print(int elem)
{
 cout<<elem<<' ';
}
int main(int argc, char* argv[])
{
 vector<int> col1;
 for (int i=1;i<=9;i++)
 {
  col1.push_back(i);
 }
 for_each(col1.begin(),col1.end(),print);
 cout<<endl;
} 
这里的for_each函数针对col1.begin,col1.end区间内的每个元素调用print函数。

bool isPrime(int number)
{
 number = abs(number);
 if (number==0||number==1)
 {
  return true;
 }
 int divisor;
 for (divisor=number/2;number%divisor!=0;--divisor)
 {
  ;
 }
 return divisor ==1;
}
int main(int argc, char* argv[])
{
    list<int> col1;
 for(int i=24;i<=30;++i)
 {
  col1.push_back(i);
 }
 list<int>::iterator pos;
 pos = find_if(col1.begin(),col1.end(),isPrime);
 if (pos!=col1.end())
 {
  cout<<*pos<<" is first prime number found"<<endl;
 }
 else
 {
  cout<<"no found"<<endl;
 }
} 
在这个例子中。find_if算法在给定区间内寻找使被传入之一元判断结果为true的第一个元素。

int main(int argc, char* argv[])
{
    deque<string>col1;
 col1.assign(3,string("string"));
 col1.push_back("last string");
 col1.push_front("first sting");
 copy(col1.begin(),col1.end(),ostream_iterator<string>(cout,"\n"));
 cout<<endl;
 col1.pop_front();
 col1.pop_back();
 for (int i=1;i<col1.size();++i)
 {
  col1[i]="another "+col1[i];
 }
 col1.resize(4,"resized sting");
 copy(col1.begin(),col1.end(),ostream_iterator<string>(cout,"\n"));
} 

输出：

first string

string

string

string

last string

string

another string

another string

resized string

int main(int argc, char* argv[])
{
   list<char> coll;
   for(char c='a';c<='z';++c)
   {
    coll.push_back(c);
   }
   while (!coll.empty())
   {
    cout<<coll.front()<<' ';
    coll.pop_front();

   }
   cout<<endl;

} 

front输出第一个。pop_front弹出第一个元素但不会返回被删除的元素。所以两个不能合二为一， lists并没有提供以operator[]直接存取元素的能力

 关联式容器：

sets:set的内部元素依据其值自动排序，每个值只能出现一次。不允许重复

Multisets：和set相同。只不过它允许重复元素。

Maps:Maps的元素都是"key/value"，每个元素有一个键，每一个键只能出现一次。不允许重复。

Multimaps：允许重复元素。multimap可被当做字典。

container::iterator

这种迭代器以读写模式遍历元素

container::const_iterator

 这种迭代器以只读模式遍历元素。

int main(int argc, char* argv[])
{
 typedef std::map< int, int > Map;
 Map map; 
 map[ 0 ] = 1;
 map[ 2 ] = 3; 
 Map::iterator p = map.begin( );
 std::cout << "map[ " << p->first
  << " ] = " << p->second << ";\n";
} 

iterator->first取键。iterator->second取值

 map<char, int> m;
 for(int i=0; i<26; i++) {
  m.insert(make_pair((char)('A'+i), 65+i));
 }
 char ch = 'G'; 
 map<char, int>::iterator p;
 p = m.find(ch);
 if(p != m.end())
  cout << "Its ASCII value is  " << p->second;
 else
    cout << "Key not in map.\n";

用make_pair将键值插入map

int main(int argc, char* argv[])
{
   list<int> coll;
   for (int i=1;i<=9;++i)
   {
    coll.push_back(i);
   }
   list<int>::iterator pos = coll.begin();
   cout<<*pos<<endl;
   advance(pos,3);
   cout<<*pos<<endl;
   advance(pos,-1);
   cout<<*pos<<endl;
}

advance将跌加器加

list<int> coll;
   for (int i=-3;i<=9;++i)
   {
    coll.push_back(i);
   }
   list<int>::iterator pos;
   pos = find(coll.begin(),coll.end(),5);
   if (pos !=coll.end())
   {
    cout <<"difference between beginning and 5:"<<distance(coll.begin(),pos)<<endl;
   }
   else
   {
       cout<<"5 not found"<<endl;
   }

distance处理两个迭代器之间的距离

iter_swap交换两个迭代器的位置。比如iter_swap(coll.begin(),++coll.begin());

reverse_iterator逆向迭代器。

算法头文件。要用c++标准程序库的算法。首先含入头文件<algorithm>,某些算法用于数值处理。因此被定义于头文件<numeric>，你经常需要用到仿函数，他们都被定义于<functional>

1:尾词 _if

如果算法有两种形式，参数个数都相同。但第一个形式的参数要求传递一个值，第二形式的参数要求传递一个函数或仿函数。那么尾词_if就派上了用场。无尾词的那个要求传递数值。有的那个要求传递函数或仿函数。比如。find()用来搜寻具有某值的元素。而find_if接受一个被当作搜寻准则的函数或仿函数。并搜寻第一个满足该准则的元素。

2：尾词_copy

用来表示在此算法中。元素不光被操作。还会被复制到目标区间。比如。reverse将区间中的元素颠倒次序。而Reverse_copy则是逆序将元素复制到另一个区间。

search_n()搜寻具有某特性的第一段n个连续元素。search搜寻某个子区间第一词出现位置。find_end搜寻某个子区间最后一次出现位置，find_first_of搜寻等于"某数个子值之一"的第一个元素。equal判断两区间是否相等。mismatch返回两序列的各组对应元素中。第一对不相等元素。lexicographical_compare判断某一序列在字典顺序下是否小于另一个序列。for_each,copy,transform变动并复制元素。将两个区间的元素合并。swap_ranges,fill以给定值替换每一个元素。replace,replace_if,replace_copy,replace_copy_if,remove,remove_if,remove_copy将不等于某特定值的元素全部复制到它处。remove_copy_if,unique,unique_copy,reverse,reverse_copy,rotate,rotate_copy,

sort,stable_sort将所有元素排序，并保持相等元素间的相对次序。portial_sort排序。直到前n个元素就位。partition改变元素次序。使得符合某准则的元素放在前面。

binary_search判断某区间是否包含某元素。include，lower_bound,upper_bound,equal_range,set_union,