条款三：理解decltype

decltype是一个怪异的发明。给定一个变量名或者表达式，decltype会告诉你这个变量名或表达式的类型。decltype的返回的类型往往也是你期望的。然而有时候，它提供的结果会使开发者极度抓狂而不得参考其他文献或者在线的Q&A网站。

我们从在典型的情况开始讨论，这种情况下decltype不会有令人惊讶的行为。与templates和auto在类型推导中行为相比（请见条款一和条款二），decltype一般只是复述一遍你所给他的变量名或者表达式的类型，如下：

   const int i = 0;            // decltype(i) is const int

   bool f(const Widget& w);    // decltype(w) is const Widget&
                               // decltype(f) is bool(const Widget&)
   struct Point{
     int x, y;                 // decltype(Point::x) is int
   };

   Widget w;                   // decltype(w) is Widget

   if (f(w)) ...               // decltype(f(w)) is bool

   template<typename T>        // simplified version of std::vector
   class vector {
   public:
     ...
     T& operator[](std::size_t index);
     ...
   };

   vector<int> v;              // decltype(v) is vector<int>
   ...
   if(v[0] == 0)               // decltype(v[0]) is int&

看到没有？毫无令人惊讶的地方。

在C++11中，decltype最主要的用处可能就是用来声明一个函数模板，在这个函数模板中返回值的类型取决于参数的类型。举个例子，假设我们想写一个函数，这个函数中接受一个支持方括号索引（也就是"[]"）的容器作为参数，验证用户的合法性后返回索引结果。这个函数的返回值类型应该和索引操作的返回值类型是一样的。

操作子[]作用在一个对象类型为T的容器上得到的返回值类型为T&。对std::deque一般是成立的，例如，对std::vector，这个几乎是处处成立的。然而，对std::vector<bool>，[]操作子不是返回bool&，而是返回一个全新的对象。发生这种情况的原理将在条款六中讨论，对于此处重要的是容器的[]操作返回的类型是取决于容器的。

decltype使得这种情况很容易来表达。下面是一个模板程序的部分，展示了如何使用decltype来求返回值类型。这个模板需要改进一下，但是我们先推迟一下：

    template<typename Container, typename Index>    // works, but
    auto authAndAccess(Container& c, Index i)       // requires
      -> decltype(c[i])                             // refinements
    {
      authenticateUser();
      return c[i];
    }

将auto用在函数名之前和类型推导是没有关系的。更精确地讲，此处使用了C++11的尾随返回类型技术，即函数的返回值类型在函数参数之后声明(“->”后边)。尾随返回类型的一个优势是在定义返回值类型的时候使用函数参数。例如在函数authAndAccess中，我们使用了c和i定义返回值类型。在传统的方式下，我们在函数名前面声明返回值类型，c和i是得不到的，因为此时c和i还没被声明。

使用这种类型的声明，authAndAccess的返回值就是[]操作子的返回值，这正是我们所期望的。

C++11允许单语句的lambda表达式的返回类型被推导，在C++14中之中行为被拓展到包括多语句的所有的lambda·表达式和函数。在上面authAndAccess中，意味着在C++14中我们可以忽略尾随返回类型，仅仅保留开头的auto`。使用这种形式的声明， 意味着将会使用类型推导。特别注意的是，编译器将从函数的实现来推导这个函数的返回类型：

    template<typename Container, typename Index>         // C++14;
    auto authAndAccess(Container &c, Index i)            // not quite
    {                                                    // correct
      authenticateUser();
      return c[i];
    }                                 // return type deduced from c[i]

条款二解释说，对使用auto来表明函数返回类型的情况，编译器使用模板类型推导。但是这样是回产生问题的。正如我们所讨论的，对绝大部分对象类型为T的容器，[]操作子返回的类型是&T, 然而条款一提到，在模板类型推导的过程中,初始表达式的引用会被忽略。思考这对下面代码意味着什么：

    std::deque<int> d;
    ...
    authAndAccess(d, 5) = 10;       // authenticate user, return d[5],
                                    // then assign 10 to it;
                                    // this won't compile!

此处，d[5]返回的是int&，但是authAndAccess的auto返回类型声明将会剥离这个引用，从而得到的返回类型是int。int作为一个右值成为真正的函数返回类型。上面的代码尝试给一个右值int赋值为10。这种行为是在C++中被禁止的，所以代码无法编译通过。

为了让authAndAccess按照我们的预期工作，我们需要为它的返回值使用decltype类型推导，即指定authAndAccess要返回的类型正是表达式c[i]的返回类型。C++的拥护者们预期到在某种情况下有使用decltype类型推导规则的需求，并将这个功能在C++14中通过decltype(auto)实现。这使这对原本的冤家（decltype和auto）在一起完美地发挥作用：auto指定需要推导的类型，decltype表明在推导的过程中使用decltype推导规则。因此，我们可以重写authAndAccess如下：

    template<typename Container, typename Index>  // C++14; works,
    decltype(auto)                                // but still
    authAndAccess(Container &c, Index i)          // requires
    {                                             // refinement
      authenticateUser();
      return c[i];
  }

现在authAndAccess的返回类型就是c[i]的返回类型。在一般情况下，c[i]返回T&，authAndAccess就返回T&，在不常见的情况下，c[i]返回一个对象，authAndAccess也返回一个对象。

decltype(auto)并不仅限使用在函数返回值类型上。当时想对一个表达式使用decltype的推导规则时，它也可以很方便的来声明一个变量：

    Widget w;
    const Widget& cw = w;
    auto myWidget1 = cw;                     // auto type deduction
                                             // myWidget1's type is Widget 
    decltype(auto) myWidget2 = cw            // decltype type deduction:
                                             // myWidget2's type is
                                             //  const Widget&

我知道，到目前为止会有两个问题困扰着你。一个是我们前面提到的，对authAndAccess的改进。我们在这里讨论。

再次看一下C++14版本的authAndAccess的声明：

    template<typename Container, typename Index>
    decltype(auto) anthAndAccess(Container &c, Index i);

这个容器是通过非const左值引用传入的，因为通过返回一个容器元素的引用是来修改容器是被允许的。但是这也意味着不可能将右值传入这个函数。右值不能和一个左值引用绑定（除非是const的左值引用，这不是这里的情况）。

诚然，传递一个右值容器给authAndAccess是一种极端情况。一个右值容器作为一个临时对象，在 anthAndAccess 所在语句的最后被销毁，意味着对容器中一个元素的引用（这个引用通常是authAndAccess返回的）在创建它的语句结束的地方将被悬空。然而，这对于传给authAndAccess一个临时对象是有意义的。一个用户可能仅仅想拷贝一个临时容器中的一个元素，例如：

    std::deque<std::string> makeStringDeque(); // factory function
    // make copy of 5th element of deque returned
    // from makeStringDeque
    auto s = authAndAccess(makeStringDeque(), 5);

支持这样的应用意味着我们需要修改authAndAccess的声明来可以接受左值和右值。重载可以解决这个问题（一个重载负责左值引用参数，另外一个负责右值引用参数），但是我们将有两个函数需要维护。避免这种情况的一个方法是使authAndAccess有一个既可以绑定左值又可以绑定右值的引用参数，条款24将说明这正是统一引用（universal reference）所做的。因此authAndAccess可以像如下声明：

    template<typename Container, typename Index>  // c is now a
    decltype(auto) authAndAccess(Container&& c,   // universal
                                 Index i);        // reference

在这个模板中，我们不知道我们在操作什么类型的容器，这也意味着我们等同地忽略了它用到的索引对象的类型。对于一个不清楚其类型的对象使用传值传递通常会冒一些风险，比如因为不必要的复制而造成的性能降低，对象切片的行为问题，被同事嘲笑，但是对容器索引的情况，正如一些标准库的索引（std::string, std::vector, std::deque的[]操作）按值传递看上去是合理的，因此对它们我们仍坚持按值传递。

然而，我们需要更新这个模板的实现，将std::forward应用给统一引用，使得它和条款25中的建议是一致的。

    template<typename Container, typename Index>     // final
    decltype(auto)                                   // C++14
    authAndAccess(Container&& c, Index i)            // version
    {
      authenticateUser();
      return std::forward<Container>(c)[i];
    }

这个实现可以做我们期望的任何事情，但是它要求使用支持C++14的编译器。如果你没有一个这样的编译器，你可以使用这个模板的C++11版本。它出了要你自己必须指定返回类型以外，和对应的C++14版本是完全一样的，

    template<typename Container, typename Index>    // final
    auto                                            // C++11
    authAndAccess(Container&& c, Index i)           // version
    -> decltype(std::forward<Container>(c)[i])
    {
      authenticateUser();
      return std::forward<Container>(c)[i];
    }

另外一个容易被你挑刺的地方是我在本条款开头的那句话：decltype几乎所有时候都会输出你所期望的类型，但是有时候它的输出也会令你吃惊。诚实的讲，你不太可能遇到这种以外，除非你是一个重型库的实现人员。

为了彻底的理解decltype的行为，你必须使你自己对一些特殊情况比较熟悉。这些特殊情况太晦涩难懂，以至于很少有书会像本书一样讨论，但是同时也可以增加我们对decltype的认识。

对一个变量名使用decltype得到这个变量名的声明类型。变量名属于左值表达式，但这并不影响decltype的行为。然而，对于一个比变量名更复杂的左值表达式，decltype保证返回的类型是左值引用。因此说，如果一个非变量名的类型为T的左值表达式，decltype报告的类型是T&。这很少产生什么影响，因为绝大部分左值表达式的类型有内在的左值引用修饰符。例如，需要返回左值的函数返回的总是左值引用。

这种行为的意义是值得我们注意的。但是在下面这个语句中

    int x = 0;

x是一个变量名，因此decltyper(x)是int。但是如果给x加上括号"(x)"就得到一个比变量名复杂的表达式。作为变量名，x是一个左值，同时C++定义表达式(x)也是左值。因此decltype((x))是int&。给一个变量名加上括号会改变decltype返回的类型。

在C++11中，这仅仅是个好奇的探索，但是和C==14中对decltype(auto)支持相结合，函数中返回语句的一个细小改变会影响对这个函数的推导类型。

    decltype(auto) f1()
    {
      int x = 0;
      ...
      return x;        // decltype(x) is int, so f1 returns int
    }

    decltype(auto) f2()
    {
      int x = 0;
      return (x);     // decltype((x)) is int&, so f2 return int&
    }

f2不仅返回值类型与f1不同，它返回的是对一个局部变量的引用。这种类型的代码将把你带上一个为定义行为的快速列车-你完全不想登上的列车。

最主要的经验教训就是当使用decltype(auto)时要多留心一些。被推导的表达式中看上去无关紧要的细节都可能影响decltype返回的类型。为了保证推导出的类型是你所期望的，请使用条款4中的技术。

同时不能更大视角上的认识。当然，decltype（无论只有decltype或者还是和auto联合使用）有可能偶尔会产生类型推导的惊奇行为，但是这不是常见的情况。一般情况下，decltype会产生你期望的类型。将decltype应用于变量名无非是正确的，因为在这种情况下，decltype做的就是报告这个变量名的声明类型。