一讲到traits，相应的就会联系到policy。那么policy是干啥的呢？

看一下下面的累加代码。

template<class T, class P>
typename traits<T>::AccuT accum(const T* ptr, int len)
{
	traits<T>::AccuT total = traits<T>::Zero();

	for (int i = 0; i < len; i++)
	{
		total += *(ptr + i);
	}

	return total;
}

注意total += *(ptr + i);这一行。这里有两个问题：

1. 并不是所有的类型都支持+=操作符的，如果传进来的是一个自定义类型，而且没有定义+=，怎么办？

2. 如果并不想使用+=，比如传进来的是个字符串，然后想逆序拼接。

想解决这2个问题，首先想到的应该就是这个地方不要hard code了，通过传进来参数的方法来动态修改这行代码。

一般有两种办法：

1. 传进来一个函数对象，然后通过函数对象来调用相应的函数

2. 使用policy类。

这里介绍第二种方法：policy

我们把累加函数改成：

template<class T, class P>
typename traits<T>::AccuT accum(const T* ptr, int len)
{
	traits<T>::AccuT total = traits<T>::Zero();

	for (int i = 0; i < len; i++)
	{
		P::accumulate(total, *(ptr + i));
	}

	return total;
}

注意我们多加了一个模板参数P， 然后调用P::accumulate(total, *(ptr + i));

现在我们来定义这个P类：

class P
{
public:
	template<class T1, class T2>
	static void accumulate(T1& total, T2 v)
	{
		total += v;
	}
};

P类里面只有一个函数，是个静态模板函数。

这样，我们就可以调用了：

	int sz[] = {1, 2, 3};
	traits<int>::AccuT avg = accum<int, P>(sz, 3) / 3;

得到结果2.

那如果我现在要传入一个字符数组，并且想逆序拼接，应该怎么做呢？

首先把char traits返回类型改成string：

template<>
struct traits<char>
{
	typedef std::string AccuT;
	static AccuT Zero(){ return std::string(); };
};

然后新增一个policy类：

class P2
{
public:
	template<class T1, class T2>
	static void accumulate(T1& total, T2 v)
	{
		total.insert(0, 1, v);
	}
};

调用一下就会发现返回值是cba了。

char str[] = {'a', 'b', 'c'};
auto ret = accum<char, P2>(str, 3);

如果调用auto ret = accum<char,P>(str, 3);就会返回abc，因为string本身也支持+=，所有P::accumulate可以正常运行，并且是顺序拼接。

这就是policy的使用，通过policy我们可以替换累加函数里面的累加算法，很灵活。

完整代码：

// ConsoleApplication1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <memory>

#include <algorithm>
#include <numeric>
#include <string>


template<typename T>
struct traits;

template<>
struct traits<char>
{
	typedef std::string AccuT;
	static AccuT Zero(){ return std::string(); };
};

template<>
struct traits<int>
{
	typedef double AccuT;
	static AccuT Zero(){ return 0.0; };
};

template<class T, class P>
typename traits<T>::AccuT accum(const T* ptr, int len)
{
	traits<T>::AccuT total = traits<T>::Zero();

	for (int i = 0; i < len; i++)
	{
		P::accumulate(total, *(ptr + i));
	}

	return total;
}

class P
{
public:
	template<class T1, class T2>
	static void accumulate(T1& total, T2 v)
	{
		total += v;
	}
};

class P2
{
public:
	template<class T1, class T2>
	static void accumulate(T1& total, T2 v)
	{
		total.insert(0, 1, v);
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	int sz[] = {1, 2, 3};
	traits<int>::AccuT avg = accum<int, P>(sz, 3) / 3;

	char str[] = {'a', 'b', 'c'};
	auto ret = accum<char, P>(str, 3);

	ret = accum<char, P2>(str, 3);

	return 0;
}

C++模板 - policy类