STL六大组件之——仿函数偷窥

　　仿函数(functor)，就是使一个类或类模板的使用看上去象一个函数。其实现就是类或类模板中对operator()进行重载，这个类或类模板就有了类似函数的行为。仿函数是智能型函数就好比智能指针的行为像指针，其就可看作是一个指针。但是智能指针是定义的一个类对象，所以在具备指针功能的同时也有其他的能力。仿函数的能力也可以超越operator（）。因为仿函数可以拥有成员函数和成员变量，这意味着仿函数拥有状态。另一个好处是可以在执行期初始化它们。

预定义的仿函数

算术类

加法：plus<T>；减法：minus<T>；乘法：multiplies<T>；除法：divides<T>；求余：modulus<T>；否定：negate<T>

关系运算类

等于：equal_to<T>；不等于：not_equal_to<T>；大于：greater<T>；大于等于：greater_equal<T>；小于：less<T>；小于等于：less_equal<T>

逻辑运算类

除了否定为一元，其他都为二元仿函数。与：logical_and<T>；或：logical_or<T>；否：logical_not<T>

　　下面是一个哈夫曼编码示例，遇到了需要对一个文件中的所有字符进行权重计算以创建每个字符的最终编码的过程，这其中有一个步骤是需要遍历已有的字符权重表以查找当前从文件中取得的字符是否已经存在于该表中，如果存在就将该表中的该字符权重加一，如不存在则需要新建一个存储 node 以存储该字符，并将该 node 结构添加到已有的权重表中。考虑到需要在权重表中进行字符查找以及之后创建 Huffman Tree 时可能需要对该表各项进行排序所以选用 vector<Node>作为存储容器，查找及排序可以使用 algorithm 头文件当中的 sort 和 find 算法。

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>//for bind2nd func;
 
#ifndef HUFFMAN_H
#define HUFFMAN_H
 
using namespace std;
 
class Huffman
{
    public:
        Huffman(void);
        //huffman(File file, File srcTable);
        void encode(const string& file);
        void decode(const string& file, const string& srcTable) const;
        ~Huffman();
    private:
        //table node
        typedef struct
        {
            char letter;
            int  level;
            int  parent;
            int direction;//-1 for no parent, 0 for left, 1 right;
        }Node;
        vector<Node> nodeTable;//can be sorted;
         
        //仿函数,用于find_if，侦测字符是否已经存在；
        //template <typename T1, typename T2>
        class Comparer : public binary_function<Node, char, bool>
        {
            public:
                Comparer(const char ch):_ch(ch){};
 
                const bool operator()(const vector<Node>::value_type& node, char ch) const
                {
                    return node.letter == ch;
                }
 
            private:
                char _ch;
        };
};
 
#endif

#include "Huffman.h"
 
Huffman::Huffman(void)
{
    //dummany;
}
 
void Huffman::encode(const string& file)
{
    ifstream fin;
    fin.open(file.c_str());
    char ch;
    while(fin.get(ch))
    {
        if (nodeTable.size() != 0)
        {             
            //仿函数
            vector<Node>::iterator result = find_if(nodeTable.begin(),nodeTable.end(),bind2nd(Comparer(ch), ch));
  
            if (result == nodeTable.end())
            {
                Node* node = new Node;
                node->letter = ch;
                node->level = 1;
                node->parent = 0;
                node->direction = -1;
            }
            else
            {
                result->level += 1;
            }
        }
        else
        {
            Node* node = new Node;
            node->letter = ch;
            node->level = 1;
            node->parent = 0;
            node->direction = -1;
        }
    }
    fin.close();
 
 
    //huffman tree;
 
}
 
void Huffman::decode(const string& file, const string& srcTable) const
{
    //dummany;
}
 
Huffman::~Huffman(void)
{
    //dummany;
}

　　此处仿函数调用过程是这样的：find_if(nodeTable.begin(), nodeTable.end(), Comparer(ch))中 Comparer(ch)只是创建了 Comparer 类的匿名方法，重载的 operator() 真正的调用是在接下来将要看到的 find_if 模板函数的这一句 pred(*first)；代码中不使用 find 而使用 find_if 是因为需要进行查找的不是 prime type 而是自行编写的符合类型，find_if 的函数原型参考如下，从原型中可以看到第一个参数是以默认的方式进行的：     

template<class InputIterator, class Predicate>
InputIterator find_if ( InputIterator first, InputIterator last, Predicate pred )
{
    for ( ; first!=last ; first++ ) if ( pred(*first) ) break;
    return first;
}

　　bind2nd 函数的作用是将 二元算子（binary functor, bf) 转化为一元算子（unary functor, uf) 还有一个类似的 bind1st ,使用时需要包含 functional 头文件；进行比较的仿函数需要继承 binary_functor<typename T1,typename T2,typename T3>，T3 一般为 bool 值, binary_functor 原型如下： 

template<class Arg1,class Arg2,class Result>
struct binary_function 
{
      typedef Arg1 first_argument_type;
      typedef Arg2 second_argument_type;
      typedef Result result_type;
};

　　这里使用的是 bind2nd 直接将得到的 char 参数 bind 到 Comparer 仿函数中，当然可以使用直接传参数到 Comparer 仿函数中人的方法，从 Huffman.h 和 Huffman.cpp 的注释中可以看到存在不同的可行方法。