modern c++ design 第十一章

 本章介绍了经常遇到的双分派的一种泛型解决方案。 C++在语法上实现了单分派， 即虚函数， 通过动态机制选择相应的函数。 双分派是形如fun(Object1* a, Object2* b). 根据a和b的实际类型动态自动分派一个处理函数。
最容易想到的方案，蛮干法： 写一大堆重载函数. 不过这种方法会有很强的依赖性。 也提供了一种泛化蛮干法的实现: Executor是实现了各种具体实现的类， 其中实现了各种Fire函数. BaseLhs是左操作数的基类, TypesLhs是一个typelist, 包括了左操作数可能的类型集合. BaseRhs和TypesRhs类似,不过针对右操作数. symmetric是是否对称, 如果对称, 则需要实现的函数减半. ResultType是返回值类型,通常为void.
    template
    <
        class Executor,
        class BaseLhs,
        class TypesLhs,
        bool symmetric = true,
        class BaseRhs = BaseLhs,
        class TypesRhs = TypesLhs,
        typename ResultType = void
    >
    class StaticDispatcher
    {
        template <class SomeLhs>
        static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
            Executor exec, NullType)
        { return exec.OnError(lhs, rhs); }
       
        template <class Head, class Tail, class SomeLhs>
        static ResultType DispatchRhs(SomeLhs& lhs, BaseRhs& rhs,
            Executor exec, Typelist<Head, Tail>)
        {           
            if (Head* p2 = dynamic_cast<Head*>(&rhs))
            {
                Int2Type<(symmetric &&
                          int(TL::IndexOf<TypesRhs, Head>::value) <
                          int(TL::IndexOf<TypesLhs, SomeLhs>::value))> i2t;

                typedef Private::InvocationTraits<
                        SomeLhs, Head, Executor, ResultType> CallTraits;
                   
                return CallTraits::DoDispatch(lhs, *p2, exec, i2t);
            }
            return DispatchRhs(lhs, rhs, exec, Tail());
        }
       
        static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs,
            Executor exec, NullType)
        { return exec.OnError(lhs, rhs); }
       
        template <class Head, class Tail>
        static ResultType DispatchLhs(BaseLhs& lhs, BaseRhs& rhs,
            Executor exec, Typelist<Head, Tail>)
        {           
            if (Head* p1 = dynamic_cast<Head*>(&lhs))
            {
                return DispatchRhs(*p1, rhs, exec, TypesRhs());
            }
            return DispatchLhs(lhs, rhs, exec, Tail());
        }

    public:
        static ResultType Go(BaseLhs& lhs, BaseRhs& rhs,
            Executor exec)
        { return DispatchLhs(lhs, rhs, exec, TypesLhs()); }
    };
实现方式还是模板元编程的方法, 利用静态递归实现. 如果对第三章内容有相当的理解,读懂这段也非常简单了.
symmetric是使用bool的模板变量的分派实现的.  利用了一个辅助类InvocationTraits. 从辅助类的使用可以看到, 不同的职责都分派给了不同的类去实现, 耦合性非常低,利于重用.
        template <class SomeLhs, class SomeRhs,
            class Executor, typename ResultType>
        struct InvocationTraits
        {
            static ResultType
        DoDispatch(SomeLhs& lhs, SomeRhs& rhs,
            Executor& exec, Int2Type<false>)
            {
                return exec.Fire(lhs, rhs);
            }
            static ResultType
        DoDispatch(SomeLhs& lhs, SomeRhs& rhs,
            Executor& exec, Int2Type<true>)
            {
                return exec.Fire(rhs, lhs);
            }
        };


由于暴力法的依存性以及查找性能, 只有在类很少时使用.  必须考虑其他的实现
对数型分派.  依赖type_info的before函数进行排序, 维护一个执行期map, 为不同的组合注册callback, 根据2分查找寻找适合的callback, 可以实现对数性能. 即O(lgn).  此实现考虑到转型的问题, 函数调用进行了一次包装. 这一段读的不是很明白.  目的是得到具体型别不丢失, 需要实际使用才能更好理解吧. 利用前面提供的Functor可以分派到泛函数. 实现:
   template
    <
        class BaseLhs,
        class BaseRhs = BaseLhs,
        typename ResultType = void,
        typename CallbackType = ResultType (*)(BaseLhs&, BaseRhs&)
    >
    class BasicDispatcher
    {
        typedef std::pair<TypeInfo,TypeInfo> KeyType;
        typedef CallbackType MappedType;
        typedef AssocVector<KeyType, MappedType> MapType;
        MapType callbackMap_;
       
        void DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun);
        bool DoRemove(TypeInfo lhs, TypeInfo rhs);
       
    public:
        template <class SomeLhs, class SomeRhs>
        void Add(CallbackType fun)
        {
            DoAdd(typeid(SomeLhs), typeid(SomeRhs), fun);
        }
       
        template <class SomeLhs, class SomeRhs>
        bool Remove()
        {
            return DoRemove(typeid(SomeLhs), typeid(SomeRhs));
        }
       
        ResultType Go(BaseLhs& lhs, BaseRhs& rhs);
    };

    // Non-inline to reduce compile time overhead...
    template <class BaseLhs, class BaseRhs,
        typename ResultType, typename CallbackType>
    void BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType>
         ::DoAdd(TypeInfo lhs, TypeInfo rhs, CallbackType fun)
    {
        callbackMap_[KeyType(lhs, rhs)] = fun;
    }
       
    template <class BaseLhs, class BaseRhs,
        typename ResultType, typename CallbackType>
    bool BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType>
         ::DoRemove(TypeInfo lhs, TypeInfo rhs)
    {
        return callbackMap_.erase(KeyType(lhs, rhs)) == 1;
    }

    template <class BaseLhs, class BaseRhs,
        typename ResultType, typename CallbackType>
    ResultType BasicDispatcher<BaseLhs,BaseRhs,ResultType,CallbackType>
               ::Go(BaseLhs& lhs, BaseRhs& rhs)
    {
        typename MapType::key_type k(typeid(lhs),typeid(rhs));
        typename MapType::iterator i = callbackMap_.find(k);
        if (i == callbackMap_.end())
        {
                throw std::runtime_error("Function not found");
        }
        return (i->second)(lhs, rhs);
    }
由于多继承的问题, static转型在菱形继承的时候不能使用, 而Dynamic的转型性能消耗较大. 所以loki提供了一个转型策略.
最后, 还有一个BasicFastDispatcher. 是常数期的分派方法.  实际是使用了数组方法解决的问题, 代价是每个类都需要包括一个宏, 这个宏定义了那个类在数组中的下标.

对我来说, 了解了这些概念足以,  暂时的应用中,对数法或者暴力法可能更为实用一些. 高阶内容留待需求的提升吧. 不过对于思想的提升, 这些概念是意义重大的.