c++11: auto 和 decltype

感谢curise的精彩讲解，内容很短但是所有相关细节都讲的很清楚。learning cycle上有人担心不写明类型会使程序易读性变差，造成不必要的错误。会上时间有限，并没有做深入讨论，这里有必要说一下。

首先，我认为有这种担心的人是错误的理解了auto和decltype的定位和C+＋11引入他们的目的。C+＋引入自动的类型推导，并不是在向动态语言靠拢，通过弱化类型实现编程的灵活性。而是在保持类型安全的前提下提高代码的可读性，易用性和通用性。

要理解这点就必须对C+＋泛型编程（GP）和为什么要泛型有一定认识，推荐阅读：刘未鹏：泛型编程：源起、实现与意义。可以说模板和模板元编程的发展，带来了全新的C+＋，编译期多态的能力，使得C+＋代码可以做到通用行和执行效率的统一，这也是C+＋能在一些领域依然不可替代的原因。C+＋11的中很多改进就是要进一步加强和改进模板编程，因为模板编程有个很大的问题：难。不仅难写，而且难用。因为语言本身缺少variadic templates, concept等支持，模板库的作者被迫使用了很多tricky的方法，难度之大已经不是一般程序员能驾驭的了。而使用一个模板库，经常要写很长的表达式，不小心写错了，编译器就给爆出一堆近似与乱码的错误信息，调试起来更是头疼。C+＋引入auto, 就是要让模板的编写和使用更加容易。

auto并不是说这个变量的类型不定，或者在运行时再确定，而是说这个变量在编译时可以由编译器推导出来，使用auto和decltype只是占位符的作用，告诉编译器这个变量的类型需要编译器推导，借以消除C+＋变量定义和使用时的类型冗余，从而解放了程序员打更多无意义的字符，避免了手动推导某个变量的类型，甚至有时候需要很多额外的开销才能绕过的类型声明。

比如很多时候在用泛型算法的时候，并不在乎变量的类型，只关心这个变量能作什么。比如下面例子中：

map< int, map<int,int> > _Map;
// see the verbose for defining a const iterator of this map
map<int, map<int,int>>::const_iterator itr1 = _Map.begin();
// now with auto our life gets simplified
const auto itr2 = _Map.begin();

我只需要知道itr2 是迭代器，能用来访问容器就够了，完全不需要打出长长的类型，万一打错，都不一定知道错在哪里，而且以后如果要修改_Map 的类型，所有的迭代器都要改, 完全不符合DRY原则。而使用auto 就避免这些问题。

auto并不是让程序员少打一些字这么简单，看下面例子：

struct A
{
    typedef int Type;
    int a;
    int b;
};

struct B
{
   typedef double Type;
   double a;
   double b;
};

template<T>
void some_func(T &t)
{
    typedef typename T::type Type;

    Type c = t.a + t.b;
    ....
}

C+＋98中，为了初始化变量C, 必须提供它的类型，所以我们用了三个typedef来做类型推导，在更复杂的模板代码中这个实现会更复杂的，这么做不仅非常麻烦，而且对用户代码是有侵入性的（使用这个函数的class 必须都定义自己的typedef）。其实在编译时，编译器完全可以自己推导出类型，只是为了符合C+＋类型声明和初始化的语法，才不得不让程序员替编译器做这些事。

struct A
{
    int a;
    int b;
};

struct B
{
   double a;
   double b;
};

template<T>
void some_func(T &t)
{
    auto c = t.a + t.b;
    ....
}

所以顺理成章，C+＋11引入了auto, 可以交给编译器的工作，都交给编译器做，让程序员更focus在实现代码逻辑上。

关于何时应该使用auto, Andrei Alexandrescu, Scott Meyers 和Herb Sutter在C++ and Beyond 2012的Ask Us Anything panel上给出了意见：鼓励在所有地方使用auto,除非你需要做一个类型转换。当然他们做了很多解释，这段视频值得多看几遍。

相对与auto, decltype 更有针对性，具体用法参照里learning cycle PPT中的例子，这里不再累述。一句话就是：auto是为所有人准备的，而decltype是提供给模板开发者的。

下面是一些auto和decltype 的用法细节，摘抄自cruise的PPT:

auto variables have the type of their initializing expression:

auto x1 = 10;
// x1: int
std::map<int, std::string> m;
auto i1 = m.begin();
// i1: std::map<int, std::string>::iterator

const/volatile and reference/pointer adornments may be added:

1 2	const auto x2 = &x1; // x2: const int const auto& i2 = m; // i2: const std::map<int, std::string>&

To get a const_iterator, use the new cbegin container function:

1 2	auto ci = m.cbegin(); // ci: std::map<int, std::string>::const_iterator

For variables not explicitly declared to be a reference:

Top-level consts/volatiles in the initializing type are ignored.
Array and function names in initializing types decay to pointers.

const std::list<int> li;
auto v1 = li;
// v1: std::list<int>
auto& v2 = li;
// v2: const std::list<int>&
float data[BufSize];
auto v3 = data;
// v3: float*
auto& v4 = data;
// v4: float (&)[BufSize]

Examples from earlier:

auto x1 = 10;
// x1: int
std::map<int, std::string> m;
auto i1 = m.begin();
// i1: std::map<int, std::string>::iterator
const auto *x2 = &x1;
// x2: const int* (const isn’t top-level)
const auto& i2 = m;
// i2: const std::map<int, std::string>&
auto ci = m.cbegin();
// ci: std::map<int, std::string>::const_iterator

Yields the type of an expression without evaluating it.

int x, *ptr;
decltype(x) i1; // i1’s type is int
decltype(ptr) p1; // p1’s type is int*
std::size_t sz = sizeof(decltype(ptr[44])); // sz = sizeof(int);
                                           // ptr[44] not evaluated

Fairly intuitive, but some quirks, e.g., parentheses can matter:

struct S { double d; }; // double
const S* p; 
... 
decltype(p->d) x1; 
decltype((p->d)) x2; // const double&

Primary use: template return types that depend on parameter types.
Common for forwarding templates:

template<typename F, typename... Ts>
auto logAndInvoke(std::ostream& os,
F&& func, Ts&&... args) ->
decltype(func(args...))
{
os << std::chrono::system_clock::now();
return func(args...);
}

Also in math-related libraries:

template<typename T1, typename T2>
auto mult(T1&& a, T2&& b) ->
decltype(a * b)
{
return a * b;
}