[大数据]Item 5: Prefer auto to explicit type declarations.

这次是对 Effective Modern C++ Item 5 的学习笔记。

C++ 显示声明可能会产生例如变量未初始化、申明类型冗长、无法形成闭包、截断等问题，通过使用 auto 可以很好解决这些问题。

避免变量未初始化

int x1; // potentially uninitialized
auto x2; // error! initializer required
auto x3 = 0; // fine, x's value is well-defined

x1 未初始化，其值可能是未定义的，这导致程序中可能隐藏着 bug。使用 auto 声明的变量未初始化将导致编译报错。

简化变量申明

考虑下面的代码，通过解引用迭代器初始化局部变量：

template<typename It>       // algorithm to dwim ("do what I mean")
void dwim(It b, It e)       // for all elements in range from
{    // b to e
	while (b != e) {
	typename std::iterator_traits<It>::value_type
	currValue = *b;
	…
	}
}

使用 auto 简化上述代码：

template<typename It>    // as before
void dwim(It b, It e)
{
	while (b != e) {
	auto currValue = *b;
	…
	}
}

申明闭包类型

在 Item 2 中介绍过 auto 可以通过类型推到得到实际的类型，考虑下面的代码片段：

auto derefUPLess =                             // comparison func.
	[](const std::unique_ptr<Widget>& p1,      // for Widgets
	   const std::unique_ptr<Widget>& p2)      // pointed to by
	{ return *p1 < *p2; };                     // std::unique_ptrs

C++14 lambda 函数参数也可以使用 auto，代码简化如下：

auto derefLess =            // C++14 comparison
	[](const auto& p1,      // function for
	   const auto& p2)      // values pointed
	{ return *p1 < *p2; };  // to by anything
	                        // pointer-like

使用 auto 的 derefLess 是一个闭包类型。也可以使用 std::function 得到闭包类型：

  std::function<bool(const std::unique_ptr<int>&,std::unique_ptr<int>&)> derefLess = [] (
                     const std::unique_ptr<int>& p1,const std::unique_ptr<int>& p2) {
    return *p1 < *p2;
  };

auto 申明的持有闭包的变量和闭包有相同的类型，并且仅使用闭包需要的内存大小。而 std::function 声明持有闭包的变量有一个固定大小内存，一旦内存大小不足，则需要申请堆内存来存储闭包。因此， std::function 申明的对象要比 auto 申明的对象占更多的内存，由于约束内嵌的使用和提供间接函数的调用，通过 std::function 对象来调用一个封装体比通过 auto 对象要慢。也就是说，std::function 方法通常体积比 auto 大且慢，还有可能导致内存不足的异常。

避免类型截断

auto 还有一个避免内存截断的优点，考虑下面的代码片段：

std::vector<int> v;
…
unsigned sz = v.size();

v.size() 返回类型是 std::vector::size_type ，一个无符号整数类型，很多程序员可能会写出上面的代码。std::vector::size_type 在 32 位机器上是 4个字节，但在 64 位机器上则为 8 字节，但是 unsigned 固定为 4 字节。上面的代码在 32 位机器上运行没有什么问题，但移植到 64 位机器上则会导致类型截断的问题。

避免类型不匹配

auto 还具有一个非常隐蔽的效果，看下面的代码：

std::unordered_map<std::string, int> m;
...
for (std::pair<std::string, int>& p : m)
{
... // do something with p
}

看上去没有什么问题？我们很有可能写出以上的迭代代码，但是 unordered_map 的 key 是 const的，即 hash map 中 std::pair 的类型是 std::pair<const std::string, int>。下面的代码将产生编译报错：

#include <unordered_map>
#include <iostream>

int main() {
  int p;
  std::unordered_map<std::string,int> m;
  m["key"]  = 10;
  for(std::pair<std::string,int>&p : m) {
    p.second  = 2;
  }
  return 0;
}

// 编译报错
main.cpp:8:38: error: invalid initialization of reference of type 'std::pair<std::__cxx11::basic_string<char>, int>&' from expression of type 'std::pair<const std::__cxx11::basic_string<char>, int>'
    8 |   for(std::pair<std::string,int>&p : m) {

不知道这个隐蔽的背景知识的情况下，使用 auto 替代则会避免上述问题：

for (auto& p : m)
{
  … // as before
}

上面介绍了几条使用 auto 的优势， 使用 auto 也有 Item 2 和 Item 6 介绍的使用陷阱，但是可以通过 Item 4 介绍的一些方法可视化其类型推导结果，auto 还是非常值得使用的。