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

/* 方法一
 *对应内置对象，函数里面处理的是常数
 * 比如:找出容器里面大于6的数的个数
 **********************************/
bool Great6(int i)
{
        return i >6;
}

bool Great10(int i)
{
        return i > 10;
}

/*方法二
 *利用函数对象，封装类，有特定名字叫仿函数，重载operator（）
 * 找出容器里面大于给定数的个数，比如说找出大于8的个数
 *****************************************************/
class GreatInt
{

public:
         GreatInt(int i): m_i(i){}
         bool operator() (int i)
         {
                 return i >m_i;
         }
private:
        int m_i;
};

/*方法三
 *利用函数对象的函数适配器
 *参数n表示比较的数
 ***************************/
int GreatN(vector<int>::iterator beg, vector<int>::iterator end, int n)
{
   return count_if(beg, end, bind2nd(greater<int>(), n));
}

int main()
{

        vector<int> ivec;
    
        for(int i =0 ; i != 10; ++i)
    ivec.push_back(i);

        int iFind = 11;
        cout<<"第一种方法输出结果:"<<endl;
        int iCount1 = count_if(ivec.begin(), ivec.end(), Great6);
        cout<<iCount1<<endl;
        iCount1 = count_if(ivec.begin(), ivec.end(), Great10);
        cout<<iCount1<<endl;
    int iCount2;
        cout<<"第二种方法输出结果:"<<endl;
        iCount2 = count_if(ivec.begin(), ivec.end(), GreatInt(6));
        cout<<iCount2<<endl;
        iCount2 = count_if(ivec.begin(), ivec.end(),GreatInt(10));
        cout<<iCount2<<endl;
        cout<<"第三种方法输出结果:"<<endl;
        cout<<GreatN(ivec.begin(), ivec.end(), 6)<<endl;
        cout<<GreatN(ivec.begin(), ivec.end(), 10)<<endl;
        

        return 0;

}

#include <iostream>
using namespace std;

const int CMP_LES = -1;
const int CMP_EQU = 0;
const int CMP_BIG = 1;

class Comparer
{
public:
           Comparer(int cmpType)
           {
               m_cmpType = cmpType;
           }

          bool operator () (int num1, int num2) const 
           {
               bool res;

               switch(m_cmpType)
               {
               case CMP_LES:
                   res = num1 < num2;
                   break;
               case CMP_EQU:
                   res = num1 == num2;
                   break;
               case CMP_BIG:
                   res = num1 > num2;
                   break;
               default:
                   res = false;
                   break;

               }

               return res;
           }

private:
           int m_cmpType;
};

void Swap(int & num1, int & num2)
{
           int temp = num1;
           num1 = num2;
           num2 = temp;
}

void SortArray(int array[], int size, const Comparer & cmp )
{
           for (int i = 0; i < size - 1; ++i)
           {
               int indx = i;

               for (int j = i + 1; j < size; ++j)
               {
                   if (cmp(array[indx], array[j])) 
                   {
                       indx = j;
                   }
               }

               if (indx != i)
               {
                   Swap(array[i], array[indx]);
               }
           }
}

void ListArray(int array[], int size)
{
           for (int i = 0; i < size; ++i)
           {
               cout << array[i] << " ";
           }
}

#define ARY_SIZE 10

int main()
{
           int array[ARY_SIZE] = {10, 12, 9, 31, 93, 34, 98, 9, 1, 20};

           cout << "The initial array is : ";
           ListArray(array, ARY_SIZE);
           cout << endl;

          SortArray(array, ARY_SIZE, Comparer(CMP_BIG)); 
           cout << "The ascending sorted array is :";
           ListArray(array, ARY_SIZE);
           cout << endl;

          SortArray(array, ARY_SIZE, Comparer(CMP_LES) );
           cout << "The descending sorted array is : ";
           ListArray(array, ARY_SIZE);
           cout << endl;

           return 0;
}

class TestIndex{  
public:  
    int index;  
    TestIndex(){  
    }  
    TestIndex(int _index):index(_index){  
    }  
    bool operator()(const TestIndex* t1,const TestIndex* t2){  
        printf("Operator():%d,%d/n",t1->index,t2->index);  
        return t1->index < t2->index;  
    }  
    bool operator < (const TestIndex& ti) const {  
        printf("Operator<:%d/n",ti.index);  
        return index < ti.index;  
    }  
};  
bool compare_index(const TestIndex* t1,const TestIndex* t2){  
    printf("CompareIndex:%d,%d/n",t1->index,t2->index);  
    return t1->index < t2->index;  
}