C++11新特性之decltype关键字的使用

一.decltype关键字介绍

decltype关键字与auto关键字相似，但又有不同之处；auto关键字是在编译时通过已经初始化的变量来确定auto所代表的类型。换句话说，auto修饰的表达式必须是已经初始化的变量；那么如果我们只是想得到此变量的类型，那又该如何做呢？这个时候就轮到decltype出场了，decltype关键字也是用来在编译时推导出一个表达式的类型，但此表达式初始化与否，在编译器都没有多大的影响。

下面是使用关键字decltype关键字的示例：

#include <iostream>
using namespace std;

int main()
{
    int x = 0;
    decltype(x) y = 1;  //y -> int
    cout << y << endl;
    decltype(x + y) z = 2; //z -> int
    cout << z << endl;

    const int& i = x;
    decltype(i) j = y;  //j -> const int &

    cout << j << endl;

    const decltype(z) *p = &z;  //*p -> const int
    decltype(z) *pi = &z;       //*pi -> int, pi->int*
    decltype(pi) *pp = &pi;     //*pp -> int*, pp->int**

    cout << pp << endl;         //打印结果：0x61fe80
    cout << *pp << endl;        //打印结果：0x61fe84
    cout << **pp << endl;       //打印结果：2

    return 0;
}

A.y和z的结果表明decltype可以根据表达式直接推导出变量的类型，这个功能和auto很像，但又有所不同，auto只能根据变量的初始化表达式推导出变量应该具有的类型，如果想要通过某个表达式得到类型，但又不希望新变量和这个表达式具有同样的值，那么这个时候auto就不太适用了。

B.j的结果表明decltype通过表达式得到的类型，可以保留表达式的引用及const限定符，decltype能够精确地推导出表达式定义本身的类型，不会像auto那样在某些情况下舍弃掉引用和cv限定符。

C.p、pi的结果表明decltype可以像auto一样，加上引用和指针，以及cv限定符。

D.pp的推导说明，当表达式是一个指针的时候，decltype仍然能够推导出表达式的实际类型(指针类型)，之后结合pp定义时的指针标记，得到的pp是一个二维指针类型

二.decltype的推导规则

decltyp(exp)的推导规则如下所示：

(1).标识符表达式和类访问表达式。

(2).函数调用(非标识符表达式，也非类访问表达式)。

(3).带括号的表达式和加法运算表达式(其他情况)。

先来说第一种情况：

#include <iostream>
using namespace std;

class Test
{
public:
    Test() {}

public:
    static const int nNumber = 0;
    int x;
};

int main()
{

    //类访问表达式
    decltype(Test::nNumber) c = 10;
    Test test;
    decltype(test.x) d = 20;
    cout << c << "," << d <<endl;

    //标识符表达式
    int y = 20;
    decltype(y) z = 30;
   return 0;
}

第二种情况：函数调用

#include <iostream>

using namespace std;

class Test
{
public:
    Test() {}

public:
    int m_nNum = -10;
};

int Test_Int();             //纯右值
int& Test_Int_One();        //左值

const int Test_Cint();      //纯右值
const int& Test_Cint_One(); //左值

const Test Test_Class();    //纯右值

int main()
{
    int x = 10;

    decltype(Test_Int()) a1 = x;        //a1->int
    cout << a1 << endl;

    decltype(Test_Cint_One()) a2 = x;   //a2->int&
    int y = a2;
    cout << y << endl;
    cout << a2 << endl;

    decltype(Test_Cint()) b1 = x;       //b1->const int
    b1 = 20;
    cout << b1 << endl;

    decltype(Test_Cint_One()) b2 = x;   //b2->const& int
    //b2 = 30;                            //error:b2只是一个只读引用，不可再为其赋值
    cout << b2 << endl;

    decltype(Test_Class()) c1 = Test();
    cout << c1.m_nNum << endl;

    return 0;
}

能够看出按照规则2推导decltype的结果和函数的返回值类型保持一致，但需要注意的是b1是int而不是const int，这是因为函数返回的int是一个纯右值，对于纯右值而言，只有类类型可以携带cv限定符，除此之外的一般都会忽略掉cv限定符；因此decltype推导出来的b1是一个int类型，而c1推导出的类型是const Test。

第三种：带括号的表达式和加法运算表达式

#include <iostream>

using namespace std;

class Test
{
public:
    Test() {}

public:
    static const int nNum = -10;
    int x = 0;
};


int main()
{
    const Test test = Test();

    decltype(test.x) a = 0;     //a->int
    decltype((test.x)) b = a;   //b->const int&
    b = 10;                     //error:b为只读引用
    cout << b << endl;

    int m =0,n=0;
    decltype(m + n) c = 10;     //c->int
    decltype(m += n) d = c;      //d ->int &


    return 0;
}

a和b的结果：仅仅多加了一对括号，它们得到的类型却不是相同的。

a的结果很明显，根据推导规则1,a的类型就是test.x的定义类型。

b的结果并不适用与推导规则1和推导规则2，根据test.x是一个左值，可知括号表达式也是一个左值，因此可以根据推导规则3，知道decltype的结果将是一个左值引用；因为test的定义时const Test,所以说foo.x是一个const int类型左值，因此decltype的推导结果是const int&.

同样的，m+n返回一个右值，decltype的结果为int。最后，m+=n返回一个左值，根据推导规则3，decltype的结果为int&.