C++11：使用 auto/decltype/result_of使代码可读易维护

C++11 终于加入了自动类型推导。

C+＋引入自动的类型推导，并不是在向动态语言靠拢（强类型语言又称静态类型语言，是指需要进行变量/对象类型声明的语言，一般情况下需要编译执行。例如C/C++/Java；弱类型语言又称动态类型语言，是指不需要进行变量/对象类型声明的语言，一般情况下不需要编译(但也有编译型的)。例如PHP/ASP/Ruby/Python/Perl/ABAP/SQL/JavaScript/Unix Shell等等）。

1） auto

在编译时可以由编译器推导出来，使用auto和decltype只是占位符的作用，告诉编译器这个变量的类型需要编译器推导。

2） decltype

decltype主要为库作者所用，但是如果是我们需要用template，那么使用它也能简洁我们的代码。

与C完全不支持动态类型的是，C++在C++98标准中就部分支持动态类型了：RTTI（RunTime Type Identification）。RTTI就是为每个类型产生一个type_info的数据，我们可以使用typeid(var)来获取一个变量的type_info。type_info::name就是类型的名字；type_info::hash_code()是C++11中新增的，返回该类型唯一的hash值。

言归正传，decltype就是不用计算表达式就可以推导出表达式所得值的类型。

struct Person
{
    std::string name;
    int age;
    std::string city;
};

想得到一系列的multimap，可以按照city，age进行分组。

第一个版本：

template<typename T, typename Fn>
multimap<T, Person> GroupBy(const vector<Person>& vt, const Fn& keySlector)
{
    multimap<T, Person> map;
    std::for_each(vt.begin(), vt.end(), [&map](const Person& person)
    {
        //keySlector返回值就是键值，通过keySelector擦除了类型
        map.insert(make_pair(keySlector(person), person)); 
    });
    
    return map;
}

通过传入key type，和获取相应值的函数（可以使用lambda），就可以获取这个multimap。但是，实际上key type就是Fn的返回值，可以不用传入：通过keySlector(person)进行判断。这里就要说说如何获取闭包的返回值类型了。获取闭包的返回值类型的方法有三种：

1.     通过decltype
2.     通过declval
3.     通过result_of

第一种方式，通过decltype：
multimap<decltype(keySlector((Person&)nulltype)), Person>或者multimap<decltype(keySlector(*((Person*)0))), Person>
这种方式可以解决问题，但不够好，因为它有两个magic number：nulltype和0。
通过declval:
multimap<decltype(declval(Fn)(declval(Person))), Person>
declval的强大之处在于它能获取任何类型的右值引用，而不管它是不是有默认构造函数，因此我们通过declval(Fn)获得了function的右值引用，然后再调用形参declval(Person)的右值引用，需要注意的是declval获取的右值引用不能用于求值，因此我们需要用decltype来推断出最终的返回值。
通过result_of
multimap<typename std::result_of<Fn(Person)>::type, Person>
std::result_of<Fn(Arg)>::type可以获取function的返回值，没有魔法数，也没有declval繁琐的写法，很优雅。其实，查看源码就知道result_of内部就是通过declval实现的，作法和方式二一样，只是简化了写法。
最终版本：

vector<Person> v = { {"aa", 20, "shanghai"}, { "bb", 25, "beijing" }};

typedef typename vector<Person>::value_type value_type;

template<typename Fn>
multimap<typename result_of<Fn(value_type)>::type, value_type>
    groupby(const vector<value_type> &v, const Fn& f)
{
    typedef typename result_of<Fn(value_type)>::type ketype;
    //typedef  decltype(declval<Fn>()(declval <value_type>())) ketype;

    multimap<ketype, value_type> mymap;
    std::for_each(begin(v), end(v), [&mymap, &f](value_type item)
    {
        mymap.insert(make_pair(f(item), item));
    });
    return mymap;
}

看一下最终的调用情况：

// group by age
auto r1 = groupby(v, [](const Person& person){return person.age; });
// group by name
auto r2 = groupby(v, [](const Person& person){return person.name; });

result_of 其实就是通过decltype来推导函数的返回类型。result_of的一种可能的实现如下：

template<class F, class... ArgTypes>
struct result_of<F(ArgTypes...)>
{
    typedef decltype( declval<F>()(declval<ArgTypes>()...) ) type;
}

另外一个使用result_of的例子：

template< class Obj >
class CalculusVer2 
{
public:
    template<class Arg>
    typename std::result_of<Obj(Arg)>::type operator()(Arg& a) const
    { 
        return member(a);
    }
private:
    Obj member;
};

总结：

auto适用于任何人，除非需要类型转换，否则你应该使用它

decltype适合推导表达式，因此在库中大量使用，当然它也可以推导函数的返回值，但是函数的返回值的推导，还是交给result_of吧！