STL算法和String

toupper,tolower
地球人都知道 C++ 的 string 没有 toupper、tolower ，好在这不是个大问题，因为我们有 STL 算法：

1.string s("heLLo");
2.transform(s.begin(), s.end(), s.begin(), ::toupper);
3.cout << s << endl;
4.transform(s.begin(), s.end(), s.begin(), ::tolower);
5.cout << s << endl;
当然，我知道很多人希望的是 s.to_upper() ，但是对于一个这么通用的 basic_string 来说，的确没办法把这些专有的方法放进来。如果你用 boost stringalgo ，那当然不在话下，你也就不需要读这篇文章了。

------------------------------------------------------------------------
trim
我们还知道 string 没有 trim ，不过自力更生也不困难，比 toupper 来的还要简单：

1.    string s("   hello   ");
2.    s.erase(0, s.find_first_not_of(" /n"));
3.    cout << s << endl;
4.    s.erase(s.find_last_not_of(' ') + 1);
5.    cout << s << endl;
注意由于 find_first_not_of 和 find_last_not_of 都可以接受字符串，这个时候它们寻找该字符串中所有字符的 absence ，所以你可以一次 trim 掉多种字符。

-----------------------------------------------------------------------
erase
string 本身的 erase 还是不错的，但是只能 erase 连续字符，如果要拿掉一个字符串里面所有的某个字符呢？用 STL 的 erase + remove_if 就可以了，注意光 remove_if 是不行的。

1.    string s("   hello, world. say bye   ");
2.    s.erase(remove_if(s.begin(),s.end(),bind2nd(equal_to<char>(), ' ')),s.end());
上面的这段会拿掉所有的空格，于是得到 hello,world.saybye。

-----------------------------------------------------------------------
replace
string 本身提供了 replace ，不过并不是面向字符串的，譬如我们最常用的把一个 substr 换成另一个 substr 的操作，就要做一点小组合：

1.    string s("hello, world");
2.    string sub("ello, ");
3.    s.replace(s.find(sub), sub.size(), "appy ");
4.    cout << s << endl;
输出为 happy world。注意原来的那个 substr 和替换的 substr 并不一定要一样长。

-----------------------------------------------------------------------
startwith, endwith
这两个可真常用，不过如果你仔细看看 string 的接口，就会发现其实没必要专门提供这两个方法，已经有的接口可以干得很好：

1.    string s("hello, world");
2.    string head("hello");
3.    string tail("ld");
4.    bool startwith = s.compare(0, head.size(), head) == 0;
5.    cout << boolalpha << startwith << endl;
6.    bool endwith = s.compare(s.size() - tail.size(), tail.size(), tail) == 0;
7.    cout << boolalpha << endwith << endl;
当然了，没有 s.startwith("hello") 这样方便。

------------------------------------------------------------------------
toint, todouble, tobool...
这也是老生常谈了，无论是 C 的方法还是 C++ 的方法都可以，各有特色：
1.    string s("123");
2.    int i = atoi(s.c_str());
3.    cout << i << endl;
4.    
5.    int ii;
6.    stringstream(s) >> ii;
7.    cout << ii << endl;
8.    
9.    string sd("12.3");
10.    double d = atof(sd.c_str());
11.    cout << d << endl;
12.    
13.    double dd;
14.    stringstream(sd) >> dd;
15.    cout << dd << endl;
16.    
17.    string sb("true");
18.    bool b;
19.    stringstream(sb) >> boolalpha >> b;
20.    cout << boolalpha << b << endl;
C 的方法很简洁，而且赋值与转换在一句里面完成，而 C++ 的方法很通用。

------------------------------------------------------------------------
split
这可是件麻烦事，我们最希望的是这样一个接口： s.split(vect, ',') 。用 STL 算法来做有一定难度，我们可以从简单的开始，如果分隔符是空格、tab 和回车之类，那么这样就够了：

1.    string s("hello world, bye.");
2.    vector<string> vect;
3.    vect.assign( istream_iterator<string>(stringstream(s)), istream_iterator<string>());
不过要注意，如果 s 很大，那么会有效率上的隐忧，因为 stringstream 会 copy 一份 string 给自己用。

------------------------------------------------------------------------
concat
把一个装有 string 的容器里面所有的 string 连接起来，怎么做？希望你不要说是 hand code 循环，这样做不是更好？

1.    vector<string> vect;
2.    vect.push_back("hello");
3.    vect.push_back(", ");
4.    vect.push_back("world");    
5.    cout << accumulate(vect.begin(), vect.end(), string(""));
不过在效率上比较有优化的余地。

-------------------------------------------------------------------------

reverse
其实我比较怀疑有什么人需要真的去 reverse 一个 string ，不过做这件事情的确是很容易：

1.  std::reverse(s.begin(), s.end());
上面是原地反转的方法，如果需要反转到别的 string 里面，一样简单：

1.  s1.assign(s.rbegin(), s.rend());
效率也相当理想。

-------------------------------------------------------------------------

解析文件扩展名
字数多点的写法：

1.    std::string filename("hello.exe");
2.    std::string::size_type pos = filename.rfind('.');
3.    std::string ext = filename.substr(pos == std::string::npos ? filename.length() : pos + 1);
不过两行，合并成一行呢？也不是不可以：

1.    std::string ext = filename.substr(filename.rfind('.') == std::string::npos ?filename.length() : filename.rfind('.') + 1);
2.我知道，rfind 执行了两次。不过第一，你可以希望编译器把它优化掉，其次，扩展名一般都很短，即便多执行一次，区别应该是相当微小。
STL 算法
distance
很多时候我们希望在一个 vector ，或者 list ，或者什么其他东西里面，找到一个值在哪个位置，这个时候 find 帮不上忙，而有人就转而求助手写循环了，而且是原始的手写循环：

1.for ( int i = 0; i < vect.size(); ++i)
2.    if ( vect[i] == value ) break;
如果编译器把 i 看作 for scope 的一部分，你还要把 i 的声明拿出去。真的需要这样么？看看这个：

1.    int dist = distance(col.begin(), find(col.begin(), col.end(), 5));
其中 col 可以是很多容器，list, vector, deque... 当然这是你确定 5 就在 col 里面的情形，如果你不确定，那就加点判断：

1.   int dist;
2.   list<int>::iterator pos = find(col.begin(), col.end(), 5);
3.   if ( pos != col.end() )
4.       dist = distance(col.begin(), pos);
我想这还是比手写循环来的好些吧。

--------------------------------------------------------------------------
max, min
这是有直接的算法支持的，当然复杂度是 O(n)，用于未排序容器，如果是排序容器...老兄，那还需要什么算法么？

1.max_element(col.begin(), col.end());
2.min_element(col.begin(), col.end());
注意返回的是 iterator ，如果你关心的只是值，那么好：

1.*max_element(col.begin(), col.end());
2.*min_element(col.begin(), col.end());
max_element 和 min_element 都默认用 less 来排序，它们也都接受一个 binary predicate ，如果你足够无聊，甚至可以把 max_element 当成 min_element 来用，或者反之：

1.*max_element(col.begin(), col.end(), greater<int>()); // 返回最小值！
2.*min_element(col.begin(), col.end(), greater<int>()); // 返回最大值当然它们的本意不是这个，而是让你能在比较特殊的情况下使用它们，例如，你要比较的是每个元素的某个成员，或者成员函数的返回值。例如：

1.#include <iostream>
2.#include <list>
3.#include <algorithm>
4.#include <string>
5.#include <boost/bind.hpp>
6.7.using namespace boost;
8.using namespace std;
9.10.struct Person
11.{
12.    Person(const string& _name, int _age)
13.        : name(_name), age(_age)
14.    {}
15.    int age;
16.    string name;
17.};
18.19.int main()
20.{
21.    list<Person> col;
22.    list<Person>::iterator pos;
23.24.    col.push_back(Person("Tom", 10));
25.    col.push_back(Person("Jerry", 12));
26.    col.push_back(Person("Mickey", 9));
27.28.    Person eldest =  *max_element(col.begin(), col.end(),  bind(&Person::age, _1) < bind(&Person::age, _2));//>=1.33
29.30.    
31.    cout << eldest.name;
32.}
输出是 Jerry ，这里用了 boost.bind ，原谅我不知道用 bind2nd, mem_fun 怎么写，我也不想知道...

-------------------------------------------------------------------------
copy_if
没错，STL 里面压根没有 copy_if ，这就是为什么我们需要这个：

1.template<typename InputIterator, typename OutputIterator, typename Predicate>
2.OutputIterator copy_if(
3.    InputIterator begin, InputIterator end, OutputIterator destBegin, Predicate p)
4.{
5.    while (begin != end) 
6.    {
7.        if (p(*begin))*destBegin++ = *begin;
8.        ++begin;
9.    }
10.    return destBegin;
11.}
把它放在自己的工具箱里，是一个明智的选择。

------------------------------------------------------------------------
惯用手法：erase(iter++)
如果你要去除一个 list 中的某些元素，那可千万小心：（下面的代码是错的！！！）
#include <iostream>
#include <algorithm>
#include <iterator>
#include <list>
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::list<int> lst(arr, arr + 10);
    for ( std::list<int>::iterator iter = lst.begin();
          iter != lst.end(); ++iter)
        if ( *iter % 2 == 0 )
            lst.erase(iter);           
    std::copy(lst.begin(), lst.end(),
        std::ostream_iterator<int>(std::cout, " "));
}
当 iter 被 erase 掉的时候，它已经失效，而后面却还会做 ++iter ，其行为无可预期！如果你不想动用 remove_if ，那么唯一的选择就是：
#include <iostream>
#include <algorithm>
#include <iterator>
#include <list>
int main()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::list<int> lst(arr, arr + 10);

    for ( std::list<int>::iterator iter = lst.begin();
          iter != lst.end(); )
        if ( *iter % 2 == 0 )
            lst.erase(iter++);
        else
            ++iter;          
    std::copy(lst.begin(), lst.end(),
        std::ostream_iterator<int>(std::cout, " "));
}

但是上面的代码不能用于 vector, string 和 deque ，因为对于这些容器， erase 不光令 iter 失效，还令 iter 之后的所有 iterator 失效！
下面给出vector的例子
1.#include <iostream>
2.#include <algorithm>
3.#include <iterator>
4.#include <vector>
5.int _tmain()
6.{   
7.    int arr[] = {0,1,2,3,4,5,6,7,8,9,10};
8.    std::vector<int>recordList(arr,arr+10);
9.    std::vector<int>::iterator it = recordList.begin();
10.    for (it = recordList.begin(); it != recordList.end(); it++)
11.    {
12.        if (*it % 2 == 0)
13.        {
14.            it = recordList.erase(it);
15.            if (it != recordList.begin())
16.                it--;
17.        }
18.    }
19.    for (int i=0;i<recordList.size();i++)
20.    {
21.        cout<< recordList[i] << endl;
22.    }
23.}

-------------------------------------------------------------------------
erase(remove...) 惯用手法
上面的循环如此难写，如此不通用，如此不容易理解，还是用 STL 算法来的好，但是注意，光 remove_if 是没用的，必须使用 erase(remove...) 惯用手法：

1.#include <iostream>
2.#include <algorithm>
3.#include <iterator>
4.#include <list>
5.#include <functional>
6.#include <boost/bind.hpp>
7.8.int main()
9.{
10.    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
11.    std::list<int> lst(arr, arr + 10);
12.13.    lst.erase(remove_if(lst.begin(), lst.end(),
14.        boost::bind(std::modulus<int>(), _1, 2) == 0),
15.        lst.end()
16.    );
17.           
18.    std::copy(lst.begin(), lst.end(),
19.        std::ostream_iterator<int>(std::cout, " "));
20.}
当然，这里借助了 boost.bind ，让我们不用多写一个没用的 functor 。
简单常识——关于stream
从文件中读入一行简单，这样就行了：

1.ifstream ifs("input.txt");
2.char buf[1000];
3.ifs.getline(buf, sizeof buf);
4.string input(buf);

当然，这样没有错，但是包含不必要的繁琐和拷贝，况且，如果一行超过1000个字符，就必须用一个循环和更麻烦的缓冲管理。下面这样岂不是更简单？

1.string input;
2.input.reserve(1000);
3.ifstream ifs("input.txt");
4.getline(ifs, input);

不仅简单，而且安全，因为全局函数 getline 会帮你处理缓冲区用完之类的麻烦，如果你不希望空间分配发生的太频繁，只需要多 reserve 一点空间。

这就是“简单常识”的含义，很多东西已经在那里，只是我一直没去用。

---------------------------------------------------------------------------

一次把整个文件读入一个 string

我希望你的答案不要是这样：

1.string input;
2.while( !ifs.eof() )
3.{
4.    string line;
5.    getline(ifs, line);
6.    input.append(line).append(1, '/n');
7.}

当然了，没有错，它能工作，但是下面的办法是不是更加符合 C++ 的精神呢？

1.string input( istreambuf_iterator<char>(instream.rdbuf()), istreambuf_iterator<char>());

同样，事先分配空间对于性能可能有潜在的好处：

1.string input;
2.input.reserve(10000);
3.input.assign(istreambuf_iterator<char>(ifs.rdbuf()),istreambuf_iterator<char>());

很简单，不是么？但是这些却是我们经常忽略的事实。

补充一下，这样干是有问题的：

1.string input; 
2.input.assign(istream_iterator<char>(ifs),istream_iterator<char>());

因为它会忽略所有的分隔符，你会得到一个纯“字符”的字符串。最后，如果你只是想把一个文件的内容读到另一个流，那没有比这更快的了：

1.    fstream fs("temp.txt"); 
2.    cout << fs.rdbuf();

因此，如果你要手工 copy 文件，这是最好的（如果不用操作系统的 API）：

1.   ifstream ifs("in.txt"); 
2.   ofstream ofs("out.txt"); 
3.   ofs << in.rdbuf();

-------------------------------------------------------------------------

open 一个文件的那些选项

ios::in     Open file for reading

ios::out    Open file for writing
ios::ate    Initial position: end of file
ios::app    Every output is appended at the end of file
ios::trunc  If the file already existed it is erased
ios::binary Binary mode

-------------------------------------------------------------------------

还有 ios 的那些 flag

flag effect if set
ios_base::boolalpha input/output bool objects as alphabetic names (true, false).
ios_base::dec input/output integer in decimal base format.
ios_base::fixed output floating point values in fixed-point notation.
ios_base::hex input/output integer in hexadecimal base format.
ios_base::internal the output is filled at an internal point enlarging the output up to the field width.
ios_base::left the output is filled at the end enlarging the output up to the field width.
ios_base::oct input/output integer in octal base format.
ios_base::right the output is filled at the beginning enlarging the output up to the field width.
ios_base::scientific output floating-point values in scientific notation.
ios_base::showbase output integer values preceded by the numeric base.
ios_base::showpoint output floating-point values including always the decimal point.
ios_base::showpos output non-negative numeric preceded by a plus sign (+).
ios_base::skipws skip leading whitespaces on certain input operations.
ios_base::unitbuf flush output after each inserting operation.
ios_base::uppercase output uppercase letters replacing certain lowercase letters.

There are also defined three other constants that can be used as masks:

constant value
ios_base::adjustfield left | right | internal
ios_base::basefield dec | oct | hex
ios_base::floatfield scientific | fixed

--------------------------------------------------------------------------

用我想要的分隔符来解析一个字符串，以及从流中读取数据

这曾经是一个需要不少麻烦的话题，由于其常用而显得尤其麻烦，但是其实 getline 可以做得不错：

1.getline(cin, s, ';');    
2.while ( s != "quit" ) 
3.{ 
4.      cout << s << endl; 
5.      getline(cin, s, ';'); 
6.}

简单吧？不过注意，由于这个时候 getline 只把 ; 作为分隔符，所以你需要用 ;quit; 来结束输入，否则 getline 会把前后的空格和回车都读入 s ，当然，这个问题可以在代码里面解决。

同样，对于简单的字符串解析，我们是不大需要动用什么 Tokenizer 之类的东西了：

1.#include <iostream> 
2.#include <sstream> 
3.#include <string> 
4.5.using namespace std; 
6.7.int main() 
8.{ 
9.    string s("hello,world, this is a sentence; and a word, end."); 
10.    stringstream ss(s); 
11.    
12.    for ( ; ; ) 
13.    { 
14.        string token; 
15.        getline(ss, token, ','); 
16.        if ( ss.fail() ) break; 
17.        
18.        cout << token << endl; 
19.    } 
20.}

输出：

hello

world

this is a sentence; and a word

end.

很漂亮不是么？不过这么干的缺陷在于，只有一个字符可以作为分隔符。

--------------------------------------------------------------------------

把原本输出到屏幕的东西输出到文件，不用到处去把 cout 改成 fs

1.#include <iostream>
2.#include <fstream>
3.using namespace std;
4.int main()
5.{     
6.    ofstream outf("out.txt");  
7.    streambuf *strm_buf=cout.rdbuf();     
8.    cout.rdbuf(outf.rdbuf());  
9.    cout<<"write something to file"<<endl;  
10.    cout.rdbuf(strm_buf);   //recover  
11.    cout<<"display something on screen"<<endl; 
12.    system("PAUSE");
13.    return 0;
14.}

输出到屏幕的是：

display something on screen

输出到文件的是：

write something to file

也就是说，只要改变 ostream 的 rdbuf ，就可以重定向了，但是这招对 fstream 和 stringstream 都没用。

--------------------------------------------------------------------------

关于 istream_iterator 和 ostream_iterator

经典的 ostream_iterator 例子，就是用 copy 来输出：

1.#include <iostream> 
2.#include <fstream> 
3.#include <sstream> 
4.#include <algorithm> 
5.#include <vector> 
6.#include <iterator> 
7.8.using namespace std; 
9.10.int main() 
11.{   
12.    vector<int> vect; 
13.    for ( int i = 1; i <= 9; ++i ) 
14.        vect.push_back(i); 
15.        
16.    copy(vect.begin(), vect.end(), 
17.        ostream_iterator<int>(cout, " ") 
18.    ); 
19.    cout << endl; 
20.    
21.    ostream_iterator<double> os_iter(cout, " ~ "); 
22.    *os_iter = 1.0; 
23.    os_iter++; 
24.    *os_iter = 2.0; 
25.    *os_iter = 3.0; 
26.} 
27.
输出：

1 2 3 4 5 6 7 8 9

1 ~ 2 ~ 3 ~

很明显，ostream_iterator 的作用就是允许对 stream 做 iterator 的操作，从而让算法可以施加于 stream 之上，这也是 STL 的精华。与前面的“读取文件”相结合，我们得到了显示一个文件最方便的办法：

1.copy(istreambuf_iterator<char>(ifs.rdbuf()),istreambuf_iterator<char>(),ostreambuf_iterator<char>(cout));

同样，如果你用下面的语句，得到的会是没有分隔符的输出：

1.  copy(istream_iterator<char>(ifs), 
2.         istream_iterator<char>(), 
3.         ostream_iterator<char>(cout) 
4.    );

那多半不是你要的结果。如果你硬是想用 istream_iterator 而不是 istreambuf_iterator 呢？还是有办法：

1.    copy(istream_iterator<char>(ifs >> noskipws),  istream_iterator<char>(), ostream_iterator<char>(cout) );

但是这样不是推荐方法，它的效率比第一种低不少。
如果一个文件 temp.txt 的内容是下面这样，那么我的这个从文件中把数据读入 vector 的方法应该会让你印象深刻。

12345 234 567

89    10

程序：

1.#include <iostream> 
2.#include <fstream> 
3.#include <algorithm> 
4.#include <vector> 
5.#include <iterator> 
6.7.using namespace std; 
8.9.int main() 
10.{   
11.    ifstream ifs("temp.txt"); 
12.    
13.    vector<int> vect; 
14.    vect.assign(istream_iterator<int>(ifs),
15.        istream_iterator<int>()
16.    ); 
17.18.    copy(vect.begin(), vect.end(), ostream_iterator<int>(cout, " ")); 
19.}
20.
输出：

12345 234 567 89 10

很酷不是么？判断文件结束、移动文件指针之类的苦工都有 istream_iterator 代劳了。

-----------------------------------------------------------------------

其它算法配合 iterator

计算文件行数：

1.    int line_count = count(istreambuf_iterator<char>(ifs.rdbuf()),         istreambuf_iterator<char>(), '/n'); 

当然确切地说，这是在计算文件中回车符的数量，同理，你也可以计算文件中任何字符的数量，或者某个 token 的数量：

1.    int token_count = count(istream_iterator<string>(ifs), istream_iterator<string>(), "#include");

注意上面计算的是 “#include” 作为一个 token 的数量，如果它和其他的字符连起来，是不算数的。

------------------------------------------------------------------------
Manipulator

Manipulator 是什么？简单的说，就是一个接受一个 stream 作为参数，并且返回一个 stream 的函数，比如上面的 unskipws ，它的定义是这样的：

1.  inline ios_base& 
2.  noskipws(ios_base& __base) 
3.  { 
4.    __base.unsetf(ios_base::skipws); 
5.    return __base; 
6.  }

这里它用了更通用的 ios_base 。知道了这一点，你大概不会对自己写一个 manipulator 有什么恐惧感了，下面这个无聊的 manipulator 会忽略 stream 遇到第一个分号之前所有的输入（包括那个分号）：

1.template <class charT, class traits>
2.inline std::basic_istream<charT, traits>
3.ignoreToSemicolon (std::basic_istream<charT, traits>& s)
4.{
5.    s.ignore(std::numeric_limits<int>::max(), s.widen(';'));
6.    return s;
7.}

 

不过注意，它不会忽略以后的分号，因为 ignore 只执行了一次。更通用一点，manipulator 也可以接受参数的，下面这个就是 ignoreToSemicolon 的通用版本，它接受一个参数， stream 会忽略遇到第一个该参数之前的所有输入，写起来稍微麻烦一点：

1.struct IgnoreTo {
2.    char ignoreTo;
3.    IgnoreTo(char c) : ignoreTo(c) 
4.    {}
5.};
6.    
7.std::istream& operator >> (std::istream& s, const IgnoreTo& manip)
8.{
9.    s.ignore(std::numeric_limits<int>::max(), s.widen(manip.ignoreTo)); 
10.    return s;
11.}

但是用法差不多：

1.    copy(istream_iterator<char>(ifs >> noskipws >> IgnoreTo(';')), 
2.         istream_iterator<char>(), 
3.         ostream_iterator<char>(cout) 
4.    );

其效果跟 IgnoreToSemicolon 一样。

 

STL算法学习，小结如下：

前提:

下载stl源码： http://www.sgi.com/tech/stl/download.html

打开网页：     http://www.sgi.com/tech/stl/stl_index.html

一.函数对象： 因为很多的算法中多使用了函数对象

二元函数对象，V1和V2为输入，V3为结果
plus<T>: transform(V1.begin(), V1.end(), V2.begin(), V3.begin(),plus<double>());
其他的二元函数对象：minus,multiples,divieds,modulus.
二元断言函数对象，使用时需要bind2nd()或bind1st()来绑定比较对象。
less<T>: find_if(L.begin(), L.end(), bind2nd(less<int>(), 0));
其他的二元断言函数：equal_to,notequal_to,greater,greater_equal,less_equal,logical_and,logical_or
二元逻辑函数
binary_negate: const char* wptr = find_if(str, str + MAXLEN, compose2(not2(logical_or<bool>()),bind2nd(equal_to<char>(), ' '),  bind2nd(equal_to<char>(), '/n')));
一元函数对象
negate： transform(V1.begin(),V1.end(),V2.begin(),negate<int>());
一元断定函数对象
logical_not: transform(V.begin(), V.end(), V.begin(), logical_not<bool>());
一元逻辑函数
unary_negate:

二.函数对象发生器：主要用来填充序列。

产生不重复的随机数：

1. // Generate unique random numbers from 0 to mod: 
2.class URandGen 
3.{
4.    std::set<int> used;
5.    int limit; 
6.public: URandGen(int lim) : limit(lim)
7.        {
8.            srand(time(0));
9.        }
10.        int operator()()
11.        {
12.            while(true)
13.            {
14.                int i = int(rand()) % limit;
15.                if(used.find(i) == used.end())
16.                {
17.                    used.insert(i);
18.                    return i;
19.                }
20.            }
21.        }
22.};
23.const int sz = 10;
24.const int max = 50;
25.vector<int> x(sz), y(sz), r(sz); 
26.//An integer random number generator:
27.URandGen urg(max);
28.generate_n(x.begin(), sz, urg);

 

三.函数对象适配器 ： 将函数转化为函数对象

ptr_fun:一般函数适配器

一元实例： transform(first, last, first,compose1(negate<double>, ptr_fun(fabs)));
二元实例： list<char*>::iterator item=find_if(L.begin(), L.end(), not1(binder2nd(ptr_fun(strcmp), "OK")));

not1：对一元的断定函数对象取反的适配器。
not2: 对二元的断定函数对象取反的适配器。
mem_fun与mem_fun_ref：类成员函数的适配器,区别是一个需要指针，而另一个仅需要一般对象。如下：
shape是一个指针变量，则foreach(v.begin(),v.end(),mem_fun(&shape::draw));
 但如果shape是一般的变量，不是指针，则foreach（v.begin(),v.end(),mem_fun_ref(&shape::draw));
四.算法：

•拷贝:copy()、reverse_copy()、rotate_copy()、remove_copy() 拷贝不等于某值的元素到另一个序列。 remove_copy_if() 拷贝符合条件的到另一个序列。

•填充和生成：fill()、fill_n() 填充序列中的n个元素。 generate()为序列中的每个元素调用gen()函数。

•排列：next_permuttion() 后一个排列。prev_permutation()、partition() 划分，将满足条件的元素移动到序列的前面。 stable_partition()

•查找和替换：find()、binary_search() 在一个已经有顺序的序列上查找。 find_if()、search() 检查第二个序列是否在第一个序列中出现，且顺序相同。

•删除：注意必须调用erase()来真正删除、remove() unique()删除相邻重复元素，最好先排序。

•合并序列：merge()

•数值算法：accumulate() 对序列的每个元素进行运算后求和。 transform()也可以对每个元素进行运算。

•计数：size()总个数。 count()等于某值的元素个数。

adjacent_difference 序列中的后一个减前与他相邻的前一个得到新的序列。

 

五.所有的算法：

 accumlate ： iterator 对标志的序列中的元素之和，加到一个由 init 指定的初始值上。重载的版本不再做加法，而是传进来的二元操作符被应用到元素上。

adjacent_different ：创建一个新序列，该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计算相邻元素的差。
adjacent_find ：在 iterator 对标志的元素范围内，查找一对相邻的重复元素，如果找到返回一个 ForwardIterator ，指向这对元素的第一个元素。否则返回 last 。重载版本使用输入的二元操作符代替相等的判断。
binary_search ：在有序序列中查找 value ，如果找到返回 true 。重载的版本使用指定的比较函数对象或者函数指针来判断相等。

copy ：复制序列
copy_backward ：除了元素以相反的顺序被拷贝外，别的和 copy 相同。
count ：利用等于操作符，把标志范围类的元素与输入的值进行比较，并返回相等元素的个数
count_if ：对于标志范围类的元素，应用输入的操作符，并返回结果为 true 的次数。

equal ：如果两个序列在范围内的元素都相等，则 equal 返回 true 。重载版本使用输入的操作符代替了默认的等于操作符。

equal_range ：返回一对 iterator ，第一个 iterator 表示由 lower_bound 返回的 iterator ，第二个表示由 upper_bound 返回的 iterator 值。

fill ：将输入的值的拷贝赋给范围内的每个元素。

fill_n ：将输入的值赋值给 first 到 frist+n 范围内的元素。
find ：利用底层元素的等于操作符，对范围内的元素与输入的值进行比较。当匹配时，结束搜索，返回该元素的一个 InputIterator 。

find_if ：使用输入的函数替代了等于操作符执行了 find 。

find_end ：在范围内查找“由输入的另外一个 iterator 对标志的第二个序列”的最后一次出现。重载版本中使用了用户输入的操作符替代等于操作。

find_first_of ：在范围内查找“由输入的另外一个 iterator 对标志的第二个序列”中的任意一个元素的第一次出现。重载版本中使用了用户自定义的操作符。

for_each ：依次对范围内的所有元素执行输入的函数。

generate ：通过对输入的函数 gen 的连续调用来填充指定的范围。
generate_n ：填充 n 个元素。

includes ：判断 [first1, last1) 的一个元素是否被包含在另外一个序列中。使用底层元素的 <= 操作符，重载版本使用用户输入的函数。

inner_product ：对两个序列做内积 ( 对应的元素相乘，再求和 ) ，并将内积加到一个输入的的初始值上。重载版本使用了用户定义的操作。

inner_merge ：合并两个排过序的连续序列，结果序列覆盖了两端范围，重载版本使用输入的操作进行排序。

iter_swap ：交换两个 ForwardIterator 的值。

lexicographical_compare ：比较两个序列。重载版本使用了用户自定义的比较操作。

lower_bound ：返回一个 iterator ，它指向在范围内的有序序列中可以插入指定值而不破坏容器顺序的第一个位置。重载函数使用了自定义的比较操作。 max ：返回两个元素中的较大的一个，重载版本使用了自定义的比较操作。
max_element ：返回一个 iterator ，指出序列中最大的元素。重载版本使用自定义的比较操作。

min ：两个元素中的较小者。重载版本使用自定义的比较操作。
min_element ：类似与 max_element ，不过返回最小的元素。

merge ：合并两个有序序列，并存放到另外一个序列中。重载版本使用自定义的比较。

mismatch ：并行的比较两个序列，指出第一个不匹配的位置，它返回一对 iterator ，标志第一个不匹配的元素位置。如果都匹配，返回每个容器的 last 。重载版本使用自定义的比较操作。 next_permutation ：取出当前范围内的排列，并将其重新排序为下一个排列。重载版本使用自定义的比较操作。

nth_element ：将范围内的序列重新排序，使所有小于第 n 个元素的元素都出现在它前面，而大于它的都出现在后面，重载版本使用了自定义的比较操作。

partial_sort ：对整个序列做部分排序，被排序元素的个数正好可以被放到范围内。重载版本使用自定义的比较操作。

partial_sort_copy ：与 partial_sort 相同，除了将经过排序的序列复制到另外一个容器。 partial_sum ：创建一个新的元素序列，其中每个元素的值代表了范围内该位置之前所有元素之和。重载版本使用了自定义操作替代加法。

partition ：对范围内元素重新排序，使用输入的函数，把计算结果为 true 的元素都放在结果为 false 的元素之前。

prev_permutation ：取出范围内的序列并将它重新排序为上一个序列。如果不存在上一个序列则返回 false 。重载版本使用自定义的比较操作。

random_shuffle ：对范围内的元素随机调整次序。重载版本输入一个随机数产生操作。

remove ：删除在范围内的所有等于指定的元素，注意，该函数并不真正删除元素。内置数组不适合使用 remove 和 remove_if 函数。

remove_copy ：将所有不匹配的元素都复制到一个指定容器，返回的 OutputIterator 指向被拷贝的末元素的下一个位置。

remove_if ：删除所有范围内输入操作结果为 true 的元素。

remove_copy_if ：将所有不匹配的元素拷贝到一个指定容器。

replace ：将范围内的所有等于 old_value 的元素都用 new_value 替代。 replace_copy ：与 replace 类似，不过将结果写入另外一个容器。

replace_if ：将范围内的所有操作结果为 true 的元素用新值替代。

replace_copy_if ：类似与 replace_if ，不过将结果写入另外一个容器。

reverse ：将范围内元素重新按反序排列。

reverse_copy ：类似与 reverse ，不过将结果写入另外一个容器。

rotate ：将范围内的元素移到容器末尾，由 middle 指向的元素成为容器第一个元素。

rotate_copy ：类似与 rotate ，不过将结果写入另外一个容器。

search ：给出了两个范围，返回一个 iterator ，指向在范围内第一次出现子序列的位置。重载版本使用自定义的比较操作。

search_n ：在范围内查找 value 出现 n 次的子序列。重载版本使用自定义的比较操作。 set_difference ：构造一个排过序的序列，其中的元素出现在第一个序列中，但是不包含在第二个序列中。重载版本使用自定义的比较操作。

set_intersection ：构造一个排过序的序列，其中的元素在两个序列中都存在。重载版本使用自定义的比较操作。
set_symmetric_difference ：构造一个排过序的序列，其中的元素在第一个序列中出现，但是不出现在第二个序列中。重载版本使用自定义的比较操作。

set_union ：构造一个排过序的序列，它包含两个序列中的所有的不重复元素。重载版本使用自定义的比较操作。

sort ：以升序重新排列范围内的元素，重载版本使用了自定义的比较操作。

stable_partition ：与 partition 类似，不过它不保证保留容器中的相对顺序。

stable_sort ：类似与 sort ，不过保留相等元素之间的顺序关系。

swap ：交换存储在两个对象中的值。

swap_range ：将在范围内的元素与另外一个序列的元素值进行交换。

transform ：将输入的操作作用在范围内的每个元素上，并产生一个新的序列。重载版本将操作作用在一对元素上，另外一个元素来自输入的另外一个序列。结果输出到指定的容器。

unique ：清除序列中重复的元素，和 remove 类似，它也不能真正的删除元素。重载版本使用了自定义的操作。

unique_copy ：类似与 unique ，不过它把结果输出到另外一个容器。

upper_bound ：返回一个 iterator ，它指向在范围内的有序序列中插入 value 而不破坏容器顺序的最后一个位置，该位置标志了一个大于 value 的值。重载版本使用了输入的比较操作。 堆算法： C++ 标准库提供的是 max-heap 。一共由以下 4 个泛型堆算法。

make_heap ：把范围内的元素生成一个堆。重载版本使用自定义的比较操作。

pop_heap ：并不是真正的把最大元素从堆中弹出，而是重新排序堆。它把 first 和 last-1 交换，然后重新做成一个堆。可以使用容器的 back 来访问被“弹出“的元素或者使用 pop_back 来真正的删除。重载版本使用自定义的比较操作。

push_heap ：假设 first 到 last-1 是一个有效的堆，要被加入堆的元素在位置 last-1 ，重新生成堆。在指向该函数前，必须先把元素插入容器后。重载版本使用指定的比较。

sort_heap ：对范围内的序列重新排序，它假设该序列是个有序的堆。重载版本使用自定义的比较操作。
 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/cqb11111111/archive/2008/11/05/3220010.aspx