Step By Step(C++模板Policy)

一、Policy类：

    该篇博客中的代码示例将承接上一篇博客(C++模板Trait)中给出的累加器的例子。在之前的代码中，我们都是让累加器完成固定的累加行为，即累加求和。然而事实上，我们仍然可以修改该函数的累加算法，比如将求和算法改为求积算法。或者说，如果参数类型是字符的话，我们也可以通过该函数进行指定形式的字符连接。在实际的代码修改中，我们只需将total += *begin代码行替换为我们为该函数指定的Policy模板参数，这样我们就将该模板参数称为该函数累加过程的一个Policy。见如下代码示例和关键性注释：

    #include <stdio.h>
    
    template<typename T>
    class AccumulationTraits;
    
    template<>
    class AccumulationTraits<char> {
    public:
        typedef int AccT;
        static AccT zero() { return 0; }
    };
    
    template<>
    class AccumulationTraits<short> {
    public:
        typedef int AccT;
        static AccT zero() { return 0; }
    };
    
    template<>
    class AccumulationTraits<int> {
    public:
        typedef long long AccT;
        static AccT zero() { return 0; }
    };
    
    template<>
    class AccumulationTraits<unsigned int> {
    public:
        typedef unsigned long long AccT;
        static AccT zero() { return 0; }
    };
    
    template<>
    class AccumulationTraits<float> {
    public:
        typedef double AccT;
        static AccT zero() { return 0; }
    };
    
    class SumPolicy {
    public:
        template<typename T1,typename T2>
        static void accumulate(T1& total, T2 const& value) {
            total += value;
        }
    };
    
    class MultiPolicy {
    public:
        template<typename T1,typename T2>
        static void accumulate(T1& total, T2 const& value) {
            total *= value;
        }
    };
    
    template<typename T, typename Policy = SumPolicy, typename Traits = AccumulationTraits<T> >
    class Accum {
    public:
        typedef typename Traits::AccT AccT;
        static AccT accumulate(T const* begin, T const* end) {
            AccT total = Traits::zero();
            while (begin != end) {
                Policy::accumulate(total,*begin);
                ++begin;
            }
            return total;
        }
    };
    
    int main() {
        int test[5] = {1,2,3,4,5};
        int r = Accum<int,MultiPolicy>::accumulate(test,test + 5);
        printf("r is %d.",r);
        return 0;
    }
    //r is 0.

    这里之所以结果为0，是因为Traits类AccumulationTraits<int>::zero()方法返回的值是0。通过这个示例，可以让我们清楚的认识到，是组合使用Traits和Policy的时候，应该讲更多的细节问题考虑进来。
    
二、Traits和Policy的主要差别：

    以下为Trait的特征和适用场景：
    1. Trait表述了模板参数的一些自然的额外属性。
    2. Trait可以是固定Trait，也就是说， 不需要通过模板参数进行传递。
    3. Trait参数通常都具有很自然的缺省值，该缺省值很少会被改写，或者说是根本就不能被改写。
    4. Trait参数可以紧密依赖于一个或多个主参数。
    5. Trait通常都是用Trait模板来实现的。
    
    下面是Policy的特征和应用场景：
    1. Policy表述了泛型函数和泛型类的一些可配置行为。
    2. 如果不以模板参数的形式进行传递的话，Policy Class几乎不起作用。
    3. Policy参数并不需要具有缺省值，而且通常都是显示指定这个参数，尽管许多泛型组件都配置了使用频率很高的缺省Policy。
    4. Policy参数和属于同一个模板的其他参数通常都是正交的。
    5. Policy class一般都包含了成员函数。
    6. Policy即可以用普通类来实现，也可以用模板类来实现。
    
三、用模板的模板参数来实现Policy Class：

    上面的示例只是使用普通类的模板成员函数来表示Policy的，而这里我们使用模板类来重新设计这个Policy class。见如下代码片段和关键性注释：

    template<typename T1,typename T2>
    class SumPolicy {
    public:
        static void accumulate(T1& total, T2 const& value) {
            total += value;
        }
    };
    
    template<typename T1,typename T2>
    class MultiPolicy {
    public:
        static void accumulate(T1& total, T2 const& value) {
            total *= value;
        }
    };
    //这里已经将第二个模板参数定义为模板类类型，其中该模板类本身要有两个模板参数，即返回值类型和元素类型。
    template<typename T, 
             template<typename,typename> class Policy = SumPolicy, 
             typename Traits = AccumulationTraits<T> >
    class Accum {
    public:
        typedef typename Traits::AccT AccT;
        static AccT accumulate(T const* begin, T const* end) {
            AccT total = Traits::zero();
            while (begin != end) {
                Policy<AccT,T>::accumulate(total,*begin);
                ++begin;
            }
            return total;
        }
    };
    
    int main() {
        int test[5] = {1,2,3,4,5};        
        int r = Accum<int,MultiPolicy>::accumulate(test,test + 5);
        printf("r is %d.",r);
        return 0;
    }
    //r is 0.

四、类型函数：

    对于普通函数而言，我们可以将其称为值函数，既函数接收的是某些值，同时返回结果也是值。但是对于类型函数则有些不同，他们一般接收的参数是类型实参，同时也会生成一个类型或常量作为返回的结果。下面是一个简单的类型函数的示例，主要行为是通过类型函数实现sizeof的功能。

    #include <stdio.h>
    #include <iostream>
    
    using namespace std;
    
    template<typename T>
    class TypeSize {
    public:
        static size_t const value = sizeof(T);
    };
    
    int main() {
        cout << "TypeSize<int>::value = " << TypeSize<int>::value << endl;
        return 0;
    }
    //TypeSize<int>::value = 4

    从上例可以看出，所谓的类型函数并不局限于函数本身，也可以用模板类来实现。下面将给出一个更为实用的应用场景。比如，我们的函数参数是一个容器类型，该类型为模板参数，而该函数的功能是遍历容器并返回所有元素的累加之和，该返回值的类型则需要视容器元素的类型而定，这里我们先给出一个普通的实现方式，如：

    template<typename ElementT, typename ContainerT>
    ElementT sumOfElements(ContainerT const& c) {
        ElementT total = ElementT();
        ContainerT::const_iterator it = c.begin();
        for (; it != c.end(); ++it)
            total += *it;
        return total;            
    }

    在上面的例子中，我们声明的函数必须同时提供两个模板参数，既容器类型和容器元素类型的模板参数。通过类型函数，我们可以只为该函数声明一个模板参数便可，既只有容器类型的类型参数。见如下代码和关键性注释：

    #include <stdio.h>
    #include <vector>
    #include <list>
    #include <stack>
    #include <typeinfo>
    #include <iostream>
    #include <conio.h>
    
    using namespace std;
    
    template<typename T>
    class ElementT;       //基本模板，缺省情况下不需要提供定义。
    
    template<typename T>
    class ElementT<vector<T> > {  //基于vector的特化
    public:
        typedef T Type;
    };
    
    template<typename T>
    class ElementT<list<T> > {    //基于list的特化
    public:
        typedef T Type;
    };
    
    template<typename T>
    class ElementT<stack<T> > {   //基于stack的特化
    public:
        typedef T Type;
    };
    
    template<typename T>
    void printElementType(T const& c) { //一个普通的测试方法，用于测试上面的类型函数。
        cout << "Container of " << typeid(typename ElementT<T>::Type).name() 
             << " elements.\n";
    }
    //在这里我们可以看到，sumOfElement只有一个模板参数了，而另一个类型参数，既元素的
    //的类型，我们已经通过类型函数获取到了。    
    template<typename C>
    typename ElementT<C>::Type sumOfElement(C const& c) {
        typedef typename ElementT<C>::Type Type;
        Type total = Type();
        C::const_iterator it = c.begin();
        for (; it != c.end(); ++it)
            total += *it;
        return total;
    }
    
    int main() {
        stack<bool> s;
        printElementType(s);
        vector<int> v;
        v.push_back(1);
        v.push_back(3);
        v.push_back(5);
        v.push_back(7);
        v.push_back(9);
        int r = sumOfElement(v);
        printf("The result of sumOfElement is %d.",r);
        getch();
        return 0;
    }
    //Container of bool elements.
    //The result of sumOfElement is 25.