模板的泛化，全特化，偏特化

首先看泛化

/**
 * @brief 类型转换模板类(F 源类型， T 目标类型)
 */
template<class F, class T>
class LexicalCast
{
public:
    T operator()(const F& v)
    {
        return boost::lexical_cast<T>(v);
    }
};

这是一个仿函数的写法，类的对象可以向函数一样使用，传入源类型就返回目标类型，不管源类型和目标类型是什么样的，这就是泛化。

再看偏特化

/**
 * @brief 类型转换模板类片特化(YAML String 转换成 std::vector<T>)
 */
template<class T>
class LexicalCast<std::string, std::vector<T> > {
public:
    std::vector<T> operator()(const std::string& v) {
        YAML::Node node = YAML::Load(v);
        typename std::vector<T> vec;
        std::stringstream ss;
        for(size_t i = 0; i < node.size(); ++i) {
            ss.str("");
            ss << node[i];
            vec.push_back(LexicalCast<std::string, T>()(ss.str()));
        }
        return vec;
    }
};

这里类就是上一个类的偏特化，两个泛型参数变成一个泛型参数了，为什么要这样，因为boost::lexical_cast(v);并不能转换所有的类型，而且可能当泛型参数符合这种形式的时候<std::string, std::vector > ，我们想做一些特殊的处理，这时候编译器首先就会找到偏特化的版本，如果没有偏特化的版本就使用泛化的处理。

再看特化

template<>
class LexicalCast<std::string, Person>
{
public:
    Person operator() (const std::string v)
    {
        YAML::Node node = YAML::Load(v);
        Person p;
        p.m_name = node["name"].as<std::string>();
        p.m_age = node["age"].as<int>();
        p.m_sex = node["sex"].as<int>();
        return p;
    }
};

特化就是所有的模板参数的类型都被确定了，那么如果使用的时候模板参数和特化版一样就先使用特化版的。