[Effective modern cpp] auto关键字

优先使用auto而非类型全称的好处

避免未初始化变量

  int a = 0;
  auto b; //编译报错，未初始化
  auto c = 1; //c的类型为int 且初始化为1

减少代码量，避免变量声明引起的歧义

  template <typename It>
  void dwim(It b,It c){
  	while(b!=c){
  	  typename std::iterator_traits<It>::value_type //我们需要输入这么长的类型声明代码
  	    currentvalue = *b;
  	    ....
  	}
  }

  template <typename It>
  void dwim(It b,It c){
  	while(b!=c){
  	  auto currentvalue = *b;
  	  ....
  	}
  }

对于auto与 std::function封装体之间的比较,auto更胜一筹

在c++11中

  auto compare = [](const std::unique_ptr<Widget>& p1,
                    const std::unique_ptr<Widget>& p2)-> bool{
                      return *p1 <*p2;
                    };
  std::function<bool(const std::unique_ptr<Widget>&,
  					 const std::unique_ptr<Widget>&)> 
  function = [](const std::unique_ptr<Widget>& p1,
                    const std::unique_ptr<Widget>& p2)-> bool{
                      return *p1 <*p2;
                    };

通常使用一个auto去声明一个持有封装体的变量与封装体的类型一致，且大小相同。
而std::function是固定内存大小，当固定内存大小满足不了封装体的要求，则需要重新开辟堆空间存储这个封装体，导致的结果就是std::function对象一般会比auto声明的对象使用更多的内存。由于实现细节中，约束内嵌的使用和提供间接函数的调用，通过std::function对象来调用一个封装体比通过auto对象要慢。换言之，std::function方法通常体积比auto大，并且慢，还有可能导致内存不足的异常。
Note：在c++14中，可以在lambda形参使用auto

  auto compare = [](const auto& p1,
                    const auto& p2)-> bool{
                      return *p1 <*p2;
                    };

避免类型截断

   std::vector<int> v;
   ...
   unsigned sz = v.size(); //v.size()的类型是std::vector<int>::sitz_type

Note：32位Windows系统，unsigned和std::vector::size_type有同样的大小
64位的Windows，unsigned是32bit的，而std::vector::size_type是64bit的。
这意味着上面的代码在32位Windows系统上工作良好，但是在64位Windows系统上时有可能不正确，当应用程序从32位移植到64位上时，谁又想在这种问题上浪费时间呢？

   std::unordered_map<std::string, int> m;
   ...

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

Note：unordered_map中key的元素是const，即unordered_map中的元素类型是std::pair<const std::string, int>。上述代码带来的结果是会进行隐式类型转换从而降低效率。

Corner Case

“隐式”的代理类会导致auto根据初始化表达式推导出“错误的”型别。
std::vector< bool > 的operator[]操作返回类型为std::vector< bool >::reference。这么做是因为std::vector< bool >做了特化，用了一个压缩的形式（机器字）表示有持有的bool元素。
当auto推导出highpriority为std::vector< bool >::reference，并进行复制。
由于features()返回临时变量temp，而highpriority复制了temp执行operator[]返回的对象，该对象含有一个指涉到机器字的指针。当这个临时对象析构的时，highpriority会含有一个空悬指针，最终导致未定义行为。

  std::vector<bool> features(const Widget& w);
  Widget w;
  auto highpriority = features(w)[5];//auto被推导为std::vector<bool>::reference
  processwidget(w,highpriority);//未定义行为
  
  //解决办法
  auto highpriority = static_cast<bool> features(w)[5];
  //避免写出以下代码
  auto someVar = "隐形"代理型别代码