C++11 类型推导decltype

本是古典何须时尚 2022-03-30 10:12 204阅读 0赞

我们之前使用的typeid运算符来查询一个变量的类型，这种类型查询在运行时进行。RTTI机制为每一个类型产生一个type\_info类型的数据，而typeid查询返回的变量相应type\_info数据，通过name成员函数返回类型的名称。同时在C++11中typeid还提供了hash\_code这个成员函数，用于返回类型的唯一哈希值。RTTI会导致运行时效率降低，且在泛型编程中，我们更需要的是编译时就要确定类型，RTTI并无法满足这样的要求。编译时类型推导的出现正是为了泛型编程，在非泛型编程中，我们的类型都是确定的，根本不需要再进行推导。

decltype与auto关键字一样，用于进行编译时类型推导。

与auto不同的是:decltype的类型推导并不是像auto一样是从变量声明的初始化表达式获得变量的类型，decltype总是以一个普通的表达式为参数，返回改表达式的类型。

与auto相同的是:作为一个类型指示符，decltype可以将获得的类型来定义另外一个变量。

### decltype的应用 ###

1.推导出表达式类型

int i = 4;
    decltype(i) a;     //推导结果为int，a的类型为int

2.与using/typedef合用,用于定义类型,提高代码可读性

using size_t = decltype(sizeof(0));    //sizeof(a)的返回值为size_t类型
    using ptrdiff_t = decltype((int*)0 - (int*)0);
    using nullptr_t = decltype(nullptr);
    
    vector<int >vec;
    typedef decltype(vec.begin()) vectype;
    for (vectype i = vec.begin; i != vec.end(); i++)
    {
        //...
    }

3.重用匿名类型

在C++中，我们有时候会遇上一些匿名类型

#include <iostream>
    
    enum {
        K1 = 0,
        K2 = 1,
    }anon_e;
    
    union {
        decltype(anon_e) k;
        char *name;
    }anon_u;
    
    struct {
        int d;
        decltype(anon_u) id;
    }anon_s;
    
    int main()
    {
        decltype(anon_s) as;　　　　　　　　//定义了一个上面匿名的结构体
        as.id.k = decltype(anon_e)::K1;
        std::cout << as.id.k << std::endl;
        return 0;
    }

而借助decltype，我们可以重新使用匿名结构体：

4.泛型编程中结合auto，用于追踪函数的返回值类型(decltype最大的用途之一就是用于追踪返回类型的函数中)

template <typename _Tx, typename _Ty>
    auto multiply(_Tx x, _Ty y)->decltype(_Tx*_Ty)
    {
        return x*y;
    }

### decltype推导四规则 ###

(1).如果e是一个没有带括号的标记符表达式或者类成员访问表达式，那么的decltype（e）就是e所命名的实体的类型。此外，如果e是一个被重载的函数，则会导致编译错误。

(2).否则 ，假设e的类型是T，如果e是一个将亡值，那么decltype（e）为T&&

(3).否则，假设e的类型是T，如果e是一个左值，那么decltype（e）为T&。

(4).否则，假设e的类型是T，则decltype（e）为T。

标记符指的是除去关键字、字面量等编译器需要使用的标记之外的程序员自己定义的标记，而单个标记符对应的表达式即为标记符表达式。

int arr[4];    //arr为一个标记符表达式，而arr[3]+0不是。

我们来看下面这段代码：

int i=10;
    decltype(i) a;     //a推导为int
    decltype((i))b=i;  //b推导为int&，必须为其初始化，否则编译错误

仅仅为i加上了()，就导致类型推导结果的差异。这是因为，i是一个标记符表达式，根据推导规则1，类型被推导为int。而(i)为一个左值表达式(有具体名字的地址)，所以类型被推导为int&。

通过下面这段代码可以对推导四个规则作进一步了解:

int i = 4;
    int arr[5] = { 0 };
    int *ptr = arr;
    struct S{ double d; }s ;
    void Overloaded(int);
    void Overloaded(char);　　//重载的函数
    int && RvalRef();
    const bool Func(int);
    
    //规则一：推导为其类型
    decltype (arr) var1;      //int 标记符表达式
    decltype (ptr) var2;      //int *  标记符表达式
    decltype(s.d) var3;       //doubel 成员访问表达式
    
    //decltype(Overloaded) var4;    //重载函数。编译错误。
    
    //规则二：将亡值。推导为类型的右值引用。
    decltype (RvalRef()) var5 = 1;
    
    //规则三：左值，推导为类型的引用。
    decltype ((i))var6 = i;           //int&
    decltype (true ? i : i) var7 = i; //int&  条件表达式返回左值。
    decltype (++i) var8 = i;          //int&  ++i返回i的左值。
    decltype(arr[5]) var9 = i;        //int&. []操作返回左值
    decltype(*ptr)var10 = i;          //int& *操作返回左值
    decltype("hello")var11 = "hello"; //const char(&)[9]  字符串字面常量为左值，且为const左值。
    
    
    //规则四：以上都不是，则推导为本类型
    decltype(1) var12;                //const int
    decltype(Func(1)) var13=true;     //const bool
    decltype(i++) var14 = i;          //int i++返回右值

这里需要提示的是，字符串字面值常量是个左值，且是const左值，而非字符串字面值常量则是个右值。  
这么多规则，对于我们写代码的来说难免太难记了，特别是规则三。我们可以利用C++11标准库中添加的模板类is\_lvalue\_reference来判断表达式是否为左值：

std::cout << std::is_lvalue_reference<decltype(++i)>::value << std::endl;

结果1表示为左值，结果为0为非右值。  
同样的，也有is\_rvalue\_reference这样的模板类来判断decltype推断结果是否为右值。

### 限制符的继承 ###

auto类型推导时不能带走CV限制符，decltype能够带走表达式的CV限制符。不过如果对象的定义中有const或volatile限制符，使用decltype进行推导时，**对象中的**成员不会继承const或volatile限制符。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include <iostream>
    #include <type_traits>
    
    int main()
    {
        const int ic = 0;
        volatile int iv;
        struct S{ int i; };
    
        const S a = {
         0};
        volatile S b;
        volatile S*p = &b;
        std::cout << std::is_const<decltype(ic)>::value << std::endl;       //1 推导类型为:const int
        std::cout << std::is_volatile<decltype(iv)>::value << std::endl;    //1 推导类型为:volatile int
    
        std::cout << std::is_const<decltype(a)>::value << std::endl;        //1 推导类型为:const S
        std::cout << std::is_volatile<decltype(b)>::value << std::endl;     //1 推导类型为:volatile S
    
        std::cout << std::is_const<decltype(a.i)>::value << std::endl;      //0 推导类型a为const,但是成员不继承const类型
        std::cout << std::is_volatile<decltype(p->i)>::value << std::endl;  //0 推导类型p为volatile,但是成员不继承volatile类型
    
        return 0;
    }

### 限制符的冗余 ###

与auto相同的是：decltype从表达式推导出类型后，进行类型定义时，也会运行一些冗余符号，比如CV限制符以及引用符&。通常情况下，如果推导出的类型已经有了这些属性，冗余的符号则会被忽略。与auto声明中，\*也可以是冗余的不同，decltype后的\*号，并不会被编译器忽略。

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

#include <iostream>
    #include <type_traits>
    
    int main()
    {
        int i = 1;
        int& j = i;
        int *p = &i;
        const int k = 1;
    
        decltype(i)& var1 = i;
        decltype(j)& var2 = i;
        std::cout << std::is_lvalue_reference<decltype(var1)>::value << std::endl;    //1,时左值引用
        std::cout << std::is_rvalue_reference<decltype(var2)>::value << std::endl;    //0,不是右值引用
        std::cout << std::is_lvalue_reference<decltype(var2)>::value << std::endl;    //1，是左值引用
    
        //decltype(p)* var3 = &i;   //编译错误
        decltype(p)* var4 = &p;     //var4的类型为int **
    
        auto* v3 = p;               //v3的类型为int *
        v3 = & i;
        const decltype(k) var5 = 1; //冗余的const,被忽略
    
        return 0;
    }

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20220330/89d80326a79f4eba9f530af8402575f3.png