Functor——周边

使用一个库要比开发一个库简单的多， 对于使用Functor而言，我些小东西需要知道，这包括其他特性、效率以及可行扩展。

1.将请求串联起来

    template <class Fun1, class Fun2>
    Fun2 Chain(
        const Fun1& fun1,
        const Fun2& fun2)
    ...{
        return Fun2(std::auto_ptr<typename Fun2::Impl>(
            new Chainer<Fun1, Fun2>(fun1, fun2)));
    }

可以看到，Chainer在负责处理了所有问题：

    template <typename Fun1, typename Fun2>
    class Chainer : public Fun2::Impl{}

关于串起来的方法，其实很简单，在operator()处玩了个花招而已：

       ResultType operator()()
        ...{ return f1_(), f2_(); }

        ResultType operator()(Parm1 p1)
        ...{ return f1_(p1), f2_(p1); }
        
        ResultType operator()(Parm1 p1, Parm2 p2)
        ...{ return f1_(p1, p2), f2_(p1, p2); }
        
        ResultType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
        ...{ return f1_(p1, p2, p3), f2_(p1, p2, p3); }
        ...

局限性一目了然，串起来的Functor们必须共享参数，你无法定制各个参数。所以，对于参数不同的情况，BindFirst是个不错的选择。

2.转发函数的成本

    template <typename T>
    class TypeTraits
    ...{};

        template <class U> struct ReferenceTraits
        ...{
            enum ...{ result = false };
            typedef U ReferredType;
        };
        
        template <class U> struct ReferenceTraits<U&>
        ...{
            enum ...{ result = true };
            typedef U ReferredType;
        };

传引用是个不错的选择，只可惜有的时候会传成引用的引用或者对立即数传引用，好在我们有TypeTrails可以区分开这些，进而根据类型选择不同处理方式。

3.Heap分配

小对象分配器在处理这个问题的时候显示了它的优势。

4.Undo和Redo

用栈记录Functor是解决这个问题的有效途径。