1.3.1.1 Type Inference

• auto mainly used in stl container iterator and function template.
• auto sets the type of a declared variable from its initializing expression while compiling.
  auto x = {5}; //x is int type 
  auto p = &x  //p is int* type 
   
  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’re declaring variables inside a class. Instead of typing out the full name of the type of the iterator, you can use decltype:, you can’t use auto. This works because decltype doesn’t actually execute the expression given as its argumentâĂŤit is only used by the type checker to determine a type.
  class A { 
    std::vector<std::pair<int, std::string>> array; 
    decltype(array.begin()) iter; 
  };
• We can also use decltype, along with auto to make determining a function’s return type easier. Suppose that we had a function which took a template argument that is a container, and we were to return an iterator into that container, we could write:
  template <typename C> 
  auto 
  foo(const C& c) -> decltype(c.begin()) { 
    //something that returns an iterator 
    //it doesn’t have to be c.begin(), 
    //as long as it’s the right type 
  } 
   
  template<typename T, typename U> 
  auto eff(T t U u) -> decltype(T*U){ 
  .... 
  }
• We could have also done the above example with declval. The template class declval creates a default constructed type of its argument for use in type checking. However, since it can only be used in unevaluated expressions, and therefore is not evaluated, it doesn’t actually create a default constructed object, the type doesn’t even need a default constructor, and in fact, it can be used with an incomplete type. Typically it is used with decltype, since decltype doesn’t evaluate its argument. The above example could be rewritten as:
  template <typename C> 
  decltype(std::declval<const C>().begin()) 
  second(const C& c){ 
    //do something with c 
  }
  struct Default { int foo() const { return 1; } }; 
   
  struct NonDefault{ 
      NonDefault(const NonDefault&) { } 
      int foo() const { return 1; } 
  }; 
   
  decltype(Default().foo()) n1 = 1;   // type of n1 is int 
  decltype(NonDefault().foo()) n2 = n1; // error: no default ctor 
  decltype(std::declval<NonDefault>().foo()) n2 = n1; 
  //ok now,  n2 is int
• result_of usage.
  struct foo { 
      double operator()(char, int); 
  }; 
  //same 
  std::result_of<foo(char, int)>::type d1 = 10.0; 
  decltype(foo()(’c’, 1)) d2 = 10.0;