1.6.4 auto declaration

• auto sets the type of a declared variable from its initializing expression while compiling.
  auto x = {5}; //x is a std::initializer_list<double> 
  auto p = &x  //p is int* type 
   
  auto p = new vector<pair<int, string> >; 
  std::vector<std::pair<int, std::string>> array; 
  auto it = array.begin(); // they are more useful. 
   
  double fm(double, int); 
  auto pf = fm // pf is double(*)(double,int) 
   
  for (const auto& element : myarray) { 
    //do stuff that reads from element 
  }
• If you want your auto declaration to be const, or if you want your auto declaration to be a reference, you have to add them explicitly
  const std::map<int, Module>::iterator iter = modmap.find(123); 
  const auto iter = modmap.find(123); 
   
  Module& mod = vec[17]; 
  auto& mod = vec[17]; 
   
  auto p = std::make_shared<Module>(); 
  auto p = std::shared_ptr<Module>(new Module); // not safe!
• Both of these are the same and will declare a pointer. But you may go for auto* var; if you think it stresses the intent (that var is a pointer) better.
  auto var = new int(1); 
  auto *var = new int(1);
• four advantages:
  1. avoidance of uninitialized variables
  2. verbose variable declarations
     auto x2; // error! initializer required 
     auto x3 = 0; // fine, x’s value is well-defined 
      
     template<typename It> 
     void dwim(It b, It e) { 
     typename std::iterator_traits<It>::value_type 
     currValue = *b; 
      
     void dwim(It b, It e) { // better with auto 
     auto currValue = *b;
  3. the ability to directly hold closures(lambda), and in C++14, It can be used as function return type
     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 version 
     auto derefLess = // C++14 comparison 
     [](const auto& p1,  const auto& p2) // values pointed 
     { return *p1 < *p2; }; // to by anything pointer-like
  4. avoid what I call problems related to "type shortcuts."
     std::vector<int> v; 
     ... 
     unsigned sz = v.size(); 
     auto sz = v.size(); 
      
     std::unordered_map<std::string, int> m; 
     for (const std::pair<std::string, int>& p : m){ 
     ... // do something with p 
     } 
      
     for (const auto& p : m){ 
     ... // as before 
     }
• two pitfalls 1) "invisible" proxy classes 2) init brace return init_list. An invisible proxy class example is vector<bool> [] operator.
• auto can also be used as return type. Below will produce compile error, because it has ambiguity.
  auto f(int i){  // It will cause compile error. 
    if ( i < 0 ) 
      return -1; 
    else 
      return 2.0 
  }
• return deducing
  struct record { 
     std::string name; 
     int id; 
     //GUID id; _____________________________________________________________________________________________________//change id type, below doesn’t need change 
  }; 
   
   auto find_id(const std::vector<record> &people, 
               const std::string &name){...} 
   
    _________ auto ii = find_if(people.begin(), people.end(), match_name ); 
    if (ii != people.end()){...}
  1. find_id return auto type. It means that it can be used return type of function.( C++14),
  2. auto ii is another usage of auto, use auto as declaration. It’s helpful to reduce complexity of complex type, such as iterator.
• generic lambda( just like template lambda)
  auto adder  = [](auto op1, auto op2){ return op1 + op2; }; 
  vector<int> ivec={1,2,3,4}; 
  vector<string> svec={"ab","bc","cd"}; 
  accumulate(ivec.begin(), ivec.end(),0, adder ); 
  accumulate(svec.begin(),svec.end(), string(""), adder );