很多STL algorithm都是_if結尾的，讓我們可以帶function進去，若配合function object，可讓function更有彈性!!

以下的範例想利用count_if() algorithm得知vector大於n的有幾個?

 1/**//* 
 2(C) OOMusou 2007 http://oomusou.cnblogs.com
 3
 4Filename    : FunctionObjectSimple.cpp
 5Compiler    : Visual C++ 8.0 / ISO C++
 6Description : Demo how to use use Function Object
 7Release     : 01/18/2007 1.0
 8*/
 9#include <iostream>
10#include <vector>
11#include <algorithm>
12
13using namespace std;
14
15bool biggerThan3(int);
16
17// Function Object
18struct biggerThan {
19  int n;
20  biggerThan(int n) : n(n) {} // Constructor
21  bool operator() (int val) { return val > n; }
22};
23
24int main() {
25  int ia[] = {1, 2, 3, 4, 5};
26  vector<int> ivec(ia, ia + sizeof(ia) / sizeof(int));
27  int i = count_if(ivec.begin(), ivec.end(), biggerThan3);
28  cout << i << endl;
29  int j = count_if(ivec.begin(), ivec.end(), biggerThan(3));
30  cout << j << endl;
31}
32
33bool biggerThan3(int val) {
34  return val > 3;
35}

執行結果

2
2

Abstract
for_each()是STL中少數可以回傳值的algorithm，此範例在展示for_each()此特殊功能與function object可以留住state的特性。

Introduction
function object與global function的差別除了function object可以傳入參數外，還可以不使用static就可以留住state。

一個簡單的需求，想要每印n個數字就換行，並且統計出所有iterator的和，所以function object必須能留住state才知道目前印了幾個數字，且統計sum為多少。

Sample Code

 1/**//* 
 2(C) OOMusou 2007 http://oomusou.cnblogs.com
 3
 4Filename    : GenericAlgo_for_each_state_returnValue.cpp
 5Compiler    : Visual C++ 8.0 / BCB 6.0 / gcc 3.4.2 / ISO C++
 6Description : Demo how to use for_each to return value and remain state.
 7Release     : 05/13/2007 1.0
 8              05/15/2007 2.0
 9*/
10
11#include <iostream>
12#include <algorithm>
13#include <vector>
14
15using namespace std;
16
17class printElem {
18private:
19  int _n;
20  int _cnt;
21  int _sum;
22  
23public:
24  printElem(int n = 5) : _n(n), _cnt(0), _sum(0) {}
25
26  void operator() (int elem) {
27    ++_cnt;
28    _sum += elem;
29    
30    cout << elem;
31    
32    (_cnt % _n) ? cout << " " : cout << endl;
33  }
34  
35  operator int() {
36    return _sum;
37  }
38};
39
40int main() {
41  vector<int> ivec;
42  
43  for(int i = 0; i != 20; ++i) 
44    ivec.push_back(i);
45    
46  int sum = for_each(ivec.begin(), ivec.end(), printElem(5));
47  
48  cout << "sum is " << sum << endl;
49}

執行結果

0 1 2 3 4
5 6 7 8 9
10 11 12 13 14
15 16 17 18 19
sum is 190

17行

private:
  int _n;
  int _cnt;
  int _sum;

_n為設定幾個字跳行
_cnt統計目前已經印了幾個字
_sum統計目前加總結果

29行

if (_cnt % _n) 
  cout << elem << " ";
else
  cout << elem << endl;

若每印n個字，就加印換行

35行

operator int() {
  return _sum;
}

為了讓for_each()能傳回值，特別改寫operator int()，讓function object能夠傳回值。

46行

int sum = for_each(ivec.begin(), ivec.end(), printElem(5));

這樣for_each()就能風風光光的每n個字就換行，還可以順便加總結果。

Conclusion
STL真的很神奇，以上的程式想一行一行翻成C#還真的做不到呢!!

Abstract
在(原創) 如何将字符串前后的空白去除? (使用string.find_first_not_of, string.find_last_not_of) (C/C++) (STL) 中已经可顺利将字符串前后的空白去除，且程序相当的精简，在此用另外一种方式达到此要求，且可同时将whitespace去除，并且使用template写法。

Introduction
原來版本的程式在VC8可執行，但無法在Dev-C++執行，目前已經修正。

stringTrim1.cpp / C++

22和23行

是将字符串前的whitespace删除。

26和27行

是将字符串后的whitespace删除。

22行是一种变形的for写法，for的expr3区没写，并将increment写在expr2区，for从s.begin()开始，若未到s.end()尾端且是whitespace的话就继续，并且判断完whitespace就+1，其实整个for loop就相当于string.find_first_not_of()，要找到第一个不是whitespace的位置。

23行从s.begin()开始删除whitespace，但为什么要删到--c呢?因为32行的for loop，在跳离for loop之前，已经先+1，所以在此要-1才会正确。

26和27行同理，只是它是从字符串尾巴考虑。

我承认这段程序不是很好懂，是充满了C style的写法，不过++,--这种写法本来就是C的光荣、C的特色，既然C++强调多典，又是继承C语言，所以C++程序员还是得熟析这种写法。

#include <iostream>

#include <cmath>

#include <list>

using namespace std;

// a binary predicate implemented as a function:

bool same_integral_part (double first, double second)

{ return ( int(first)==int(second) ); }

// a binary predicate implemented as a class:

class is_near

{

public:

 bool operator() (double first, double second)

 { return (fabs(first-second)<5.0); }

};

int main ()

{

 double mydoubles[]={ 12.15, 2.72, 73.0, 12.77, 3.14,

                       12.77, 73.35, 72.25, 15.3, 72.25 };

 list<double> mylist (mydoubles,mydoubles+10);

 //UNIQUE以前必须要Sort,切记,它的内部实现是I,i+1的方式。

 mylist.sort();             // 2.72, 3.14, 12.15, 12.77, 12.77,            

                             // 15.3, 72.25, 72.25, 73.0, 73.35

  mylist.unique();           // 2.72, 3.14, 12.15, 12.77

                             // 15.3, 72.25, 73.0, 73.35

 mylist.unique (same_integral_part); // 2.72, 3.14, 12.15

                                       // 15.3, 72.25, 73.0

 mylist.unique (is_near());           // 2.72, 12.15, 72.25

 cout << "mylist contains:";

 for (list<double>::iterator it=mylist.begin(); it!=mylist.end(); ++it)

    cout << " " << *it;

 cout << endl;

 return 0;

}

//========================================================================
//TITLE:
//    玩玩vector
//AUTHOR:
//    norains
//DATE:
//    Saturday  10-May-2008
//Environment:
//    VS2005 + MIPS-SDK
//========================================================================

    本文不是讨论为什么要用vector替代数组，或是为什么一定要使用vector，而是在如何用vector在一些场合起到有意思的运用。本文所讨论的方式，并不是建立于推荐的原则，而仅仅是展示vector的有趣用法。在实际中是否使用，可各自掌握。
   
    1.内存动态分配
   
    最常常用的场合，vector其实也是为此而诞生的。举个很简单的例子：
   
    普通代码：
    #define NEW_SIZE  10
    int *pArr = new int[NEW_SIZE];
    ...
    delete []pArr;
   
    vector替代代码：
    std::vector<int> vct;
    vct.resize(NEW_SIZE);
   
    好处不言而喻，采用new分配内存的话，还需要调用delete来负责释放；而如果采用vector，那么，只要分配就好。释放？不管，就让编译器操心吧！
   
   
    2.存储字符串
   
    既然数组能存储字符串，那么vector自然也不甘落后咯。
   
    普通代码：
    WCHAR szPath[MAX_PATH];
    wcscpy(szPath,L"path");
   
    vector替代代码：
    std::vector<WCHAR> vctPath(MAX_PATH);
    wcscpy(&vctPath[0],L"path");
   
    在这里我们需要注意一点，标准C++中规定，vector的数据保存是必须在一段连续的内存中，所以我们在函数中可以使用&vctPath[0]的方式。注意，这里还有一个[0]下标，因为如果没有该下标，而仅仅是&vctPath，那么该地址只是对象的起始地址，而不是数据存储的起始地址。对于wcscpy函数来说，它的目标地址必须为一块连续的数据存储内存，而&vctPath[0]刚好符合。
   
    由此我们可以得出一个结论，凡是需要传递数组起始地址的场合，如果使用vector，那么都可以采用&vector[0]的方式替代。
   
   
    3.存储内存数据
   
    其实这部份内容和第2点差不多，vector既然能存储字符串，那么铁定也能存储内存的数据。
   
    普通代码：
    #define MEM_SIZE  20
    BYTE * pMem = malloc(MEM_SIZE);
    ...
    free(pMem);
   
    vector替代代码：
    std::vector<BYTE> vct;
    vct.resize(MEM_SIZE);
   
    在使用内存处理函数时只要采用和第二点相同的方式即可：
    memcpy(&vct[0],pBuf,20);
   
    不过本节的重点不在于如何存储内存数据，因为这可以通过第1、2点可以推断出来，而是想说明另外一个问题，采用vector可能可以起到简化函数行参的作用。
   
    举个例子，我们实际想写一个函数，需要转换pSource指向的内存数据，那么我们的这个函数至少需要两个参数，分别是指向分配的内存，以及该内存区域的大小：
    void Convert(BYTE * pBuf, ULONG ulSize)
    {
      for(int i = 0; i < ulSize; i ++)
      {
      ...
      }
    }
   
    但如果是用vector作为形参，由于vector可以调用size()函数获取长度，所以可以减少一个形参个数：
    void Convert(std::vector<BYTE> &vect)
    {
     for(std::vector<BYTE>::size_type i = 0; i < vect.size(); i ++)
       {
       ...
       }
    }
   
   
    4.vector的一个应用示例
   
    在文章的最后，举一个vector可以简化设计的例子。
   
    如果我们需要设计这么一个函数，输入班级的序号，然后返回班里每个人的成绩。
   
    因为需要存储每个人的成绩，所以采用数组来存储应该是一个很合理的选择。又因为每个班级的人数不一致，所以我们必须采用动态分配数组的方式：
   
    int * GetScore(int iIndexClass,int *pLen)
    {
      ...
     
      int *pNew = new int[iAmount_cls_1];
      *pLen = iAmount_cls_1；
      ...
     
      return pNew;
    }
   
    这会引发一个问题，首先我们需要增加一个形参，用来指示该数组的长度。当然，这还是其次，最重要的是，因为内存是动态分配的，需要手工释放。问题就出来了，内存的分配是函数内部分配，而释放需要调用者手工释放！万一调用者忘记释放了呢？最好的结果无非是内存慢慢被侵蚀，然后出现异常。而调用者如果记得释放呢？是不是就没问题了呢？错！在例子中，调用者应该是需要调用delete来释放内存；而如果万一某一天，GetScore函数的编写者不采用new方式，而是malloc，那么调用者调用delete释放内存会出现什么结果？喔，我也不知道，因为C++中未定义。
   
    似乎使用数组让我们走入了个两难的境地。那么，如果使用vector呢？
   
    函数如下：
       
    std::vector<int> GetScore(int iIndexClass)
    {
      ...
    
     vector<int> vct(iAmount_cls_1);
   
      ...
     
      return vct;
    }
   
    使用就非常简单咯：
    vector<int> vctScore;
    vctScore = GetScore(1);
   
    不用手工释放内存，不用增加多余的指示长度参数（因为可以调用vctScore.size()来获取），一切都那么简单，一切都那么美好，难道不是么？

std::string str("12345");

char *pChar = NULL;

pChar = std::string.c_str();

char* -> string

char* pChar = new char[10];

std::string str;

str = pChar;

string -> double

std::string str("12345");

double n;

n = atof(str.c_str());

int -> string

int i = 0;

char TempChar[100];

sprintf(TempChar, "int %d to string", i);

std::string Str(TempChar);