1.6.3.3 decltype deduction

• Basic knowledge of decltype detail can be found "How decltype Deduces the Type of an Expression: Case 1"
  1. Case1: expression whose type is to be determined is a plain variable or function parameter, like x, or a class member access, like p->m_x. In that case, decltype lives up to its name: it determines the type of the expression to be the declared type,
     vector<int> v; // decltype(v) is vector<int> 
     if (v[0] == 0) // decltype(v[0]) is int& 
      
     struct S { 
       int m_x; 
     }; 
      
     int x; 
     const int cx = 42; 
     const int& crx = x; 
     const S* p = new S(); 
      
     decltype(x) a;  // a is int 
     auto a = x;  // auto is int 
      
     decltype(cx) b; // b is const int 
     auto b = cx;  //auto ignore const, b is int 
      
     decltype(crx) c;  // c is const int&. 
     auto c = crx; //ignore reference and const, c is int 
      
     // S::m_x is declared as int: m_x_type is int 
     // Note that p->m_x cannot be assigned to. It is effectively 
     // constant because p is a pointer to const. But decltype goes 
     // by the declared type, which is int. 
     decltype(p->m_x) d; // d is int 
     auto d = p->m_x; //auto ignore const, d is int
  2. Case 2: If expr is an lvalue, then decltype(expr) is T&. If expr is an xvalue, then decltype(expr) is T&&. Otherwise, expr is a prvalue, and decltype(expr) is T.
     int x; 
     // (x) has type int, and decltype adds references to lvalues. 
     // Therefore, x_with_parens_type is int&. 
     //This is only way to get lvalue in case 2: add () around x 
     typedef decltype((x)) x_with_parens_type;
  3. Conclusion: Only T& comes from case2 lvalue, that is (x). T&& comes from case2 move(). All the other is T.
• decltype is mainly used in template function return value
  template<typename Container, typename Index> // works 
  auto authAndAccess(Container& c, Index i) -> decltype(c[i]){ 
  // ->decltype(c.begion() ) 
  authenticateUser(); 
  return c[i]; 
  } 
   
  template<typename T, typename U> 
  auto eff(T t U u) -> decltype(T*U){ 
  .... 
  } 
   
  template<typename Container, typename Index> // C++14; works, 
  __________________decltype(auto) authAndAccess(Container& c, Index i) { 
  authenticateUser(); 
  return c[i]; 
  }
• make template function support universal reference.
  template<typename Container, typename Index> // final c++14 
  decltype(auto) authAndAccess(Container&& c, Index i) { 
  authenticateUser(); 
  return std::forward<Container>(c)[i]; 
  } 
   
  template<typename Container, typename Index> // final c++11 
  auto authAndAccess(Container&& c, Index i) 
  -> decltype(std::forward<Container>(c)[i]){ 
  authenticateUser(); 
  return std::forward<Container>(c)[i]; 
  }
• The use of decltype(auto) is not limited to function return types. It can also be convenient for declaring variables when you want to apply the decltype type deduction rules to the initializing expression.
  Widget w; 
  const Widget& cw = w; 
   
  auto myWidget1 = cw; // auto type deduction: 
  // myWidget1’s type is Widget 
   
  decltype(auto) myWidget2 = cw; 
  // myWidget2’s type is  const Widget&
• 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; 
    ___________________________________________________________________________// You don’t need init expression here. 
  };
• We could have also done the above example with declval. allows you to use decltype without constructing the object,the type doesn’t even need a default constructor, and in fact, it can be used with an incomplete type. The above example could be rewritten as:
  template <typename C> 
  __________________________________________________________________________________________//Here no any variable in below expression. 
  decltype(std::declval<const C>().begin()) 
  foo(const C& c){ 
    return one iterator of c 
  }
• declval is commonly used in templates where acceptable template parameters may have no constructor in common, but have the same member function whose return type is needed.
  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. result_of was introduced in Boost, and then included in TR1, and finally in C++0x. Therefore result_of has an advantage that is backward-compatible (with a suitable library). decltype is an entirely new thing in C++, does not restrict only to return type of a function, and is a language feature.
  struct foo { 
      double operator()(char, int); 
  }; 
  //same 
  std::result_of<foo(char, int)>::type d1 = 10.0; 
  decltype(foo()(’c’, 1)) d2 = 10.0;
• There are three ways to view deducted type
  1. use IDE
  2. use Compiler
     template<typename T> // declaration only for TD; 
     class TD; // TD == "Type Displayer" 
      
     TD<decltype(x)> xType; // elicit errors containing 
     TD<decltype(y)> yType; // x’s and y’s types
  3. use typeid and std::type_info::name
     std::cout << typeid(x).name() << ’\n’; // display types for