[C++知识库]【c++11】auto与decltype

? ? ? ? c++11引入auto与decltype的关键字，目的是为了简化程序员的开发工作量，将重心转移到算法设计与业务开发中，不得不感叹编译器越来越强大！话不多说，先总结吧！

? ? ? ? 作用：让编译器在编译期间可以自动推导出变量或者表达式类型。

? ? ?auto

? ? ? ? auto可以让编译器在编译阶段推导出变量的类型，但是前提是，能从返回值或者隐身条件下看出此变量类型是什么，如果作为程序员自己看到代码都不清楚类型是什么，当然编译器也不清楚，自然推导就失效了。?

auto a = 10; // 10是int型，可以自动推导出a是int
int i = 10;auto b = i; // b是int型
auto d = 2.0; // d是double型

auto的推导规则

直接上代码

int i = 10;
auto a = i, &b = i, *c = &i; // a是int，b是i的引用，c是i的指针，auto就相当于int
auto d = 0, f = 1.0; // error，0和1.0类型不同，对于编译器有二义性，没法推导
auto e; // error，使用auto必须马上初始化，否则无法推导类型，人类都不认识的，让机器自动识别？

看代码2

void func(auto value) {} // error，auto不能用作函数参数

class A {
    auto a = 1; // error，在类中auto不能用作非静态成员变量
    static auto b = 1; // error，这里与auto无关，正常static int b = 1也不可以
    static const auto int c = 1; // ok
};

void func2() {
    int a[10] = {0};
    auto b = a; // ok
    auto c[10] = a; // error，auto不能定义数组，可以定义指针
    vector<int> d;
    vector<auto> f = d; // error，auto无法推导出模板参数
}

使用auto时要避免几种情况：

• auto的使用必须马上初始化，否则无法推导出类型
• auto在一行定义多个变量时，各个变量的推导不能产生二义性，否则编译失败
• auto不能用作函数参数
• 在类中auto不能用作非静态成员变量
• auto不能定义数组，可以定义指针
• auto无法推导出模板参数

?再来看这段代码：

int i = 0;
auto *a = &i; // a是int*
auto a2 = &i; //a2 是int*
auto &b = i; // b是int&
auto c = b; // c是int，忽略了引用

const auto d = i; // d是const int
auto e = d; // e是int

const auto& f = e; // f是const int&
auto &g = f; // g是const int&

什么情况下auto会带const与volatile的属性呢？规则如下：

• ?在不声明为引用或指针时，auto会忽略等号右边的引用类型和cv限定
• 在声明为引用或者指针时，auto会保留等号右边的引用和cv属性

什么时候用auto，应用场景最多？

?这个没有绝对的答案，在不影响代码代码可读性的前提下尽可能使用auto是蛮好的，复杂类型就使用auto，int、double这种就没有必要使用auto了，如下

auto func = [&] {
    cout << "xxx";
}; // 对于func难道不使用auto吗，反正是不关心lambda表达式究竟是什么类型。

auto asyncfunc = std::async(std::launch::async, func);
// 对于asyncfunc难道不使用auto吗，懒得写std::futurexxx等代码，而且也记不住它返回的究竟是什么...

decltype

decltype同样进行类型推导，但是与auto有何区别呢？

decltype主要用于推导表达式类型，这里只用于编译器分析表达式的类型，表达式实际不会进行运算。主要用于根据一个表达式将类型推算出来。看代码

int func() { return 0; }
decltype(func()) i; // i为int类型

int x = 0;
decltype(x) y; // y是int类型
decltype(x + y) z; // z是int类型

注意：

decltype不会像auto一样忽略引用和const volatile属性，decltype会保留表达式的引用和const volatile属性,简单来说，就是会照搬

cont int &i = 1;
int a = 2;
decltype(i) b = 2; // b是const int&

decltype推导规则

对于decltype(exp)有

• exp是表达式，decltype(exp)和exp类型相同
• exp是函数调用，decltype(exp)和函数返回值类型相同
• 其它情况，若exp是左值，decltype(exp)是exp类型的左值引用

示例代码如下：

int a = 0, b = 0;
decltype(a + b) c = 0; // c是int，因为(a+b)返回一个右值
decltype(a += b) d = c;// d是int&，因为(a+=b)返回一个左值

d = 20;
cout << "c " << c << endl; // 输出c 20

?auto和decltype的配合使用

?auto和decltype一般配合使用在推导函数返回值的类型问题上。

如果想实现这样的问题：

template<typename T, typename U>
return_value add(T t, U u) { // t和v类型不确定，无法推导出return_value类型
    return t + u;
}

如何实现呢？这样子是否可以？

template<typename T, typename U>
decltype(t + u) add(T t, U u) { // t和u尚未定义
    return t + u;
}

很可惜，答案是否定的，因为t和u都没有定义，怎么推导？编译器自己也不是很人工智能，所以编译出错，但是稍改一下就可以了

template<typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

用->制定一下，引导auto的推导的问题，完美解决！

总结：

返回值后置类型语法就是为了解决函数返回值类型依赖于参数但却难以确定返回值类型的问题。