C++11类型推导的关键字auto和decltype
Posted 老虎中的小白Gentle
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++11类型推导的关键字auto和decltype相关的知识,希望对你有一定的参考价值。
他们的语法格式:
auto varname = value;
decltype(exp) varname [= value];
稍微解释一下,看不懂没关系,耐心往下看你就会明白了:
varname 表示变量名,value 表示赋给变量的值,exp 表示一个表达式,方括号[ ]表示可有可无。
auto 和 decltype 都会自动推导出变量 varname 的类型,但是他们都推导方式有些区别:
- auto 根据=右边的初始值 value 推导出变量的类型;所以auto
要求变量必须初始化,也就是在定义变量的同时必须给它赋值,不然会报错的 - decltype 根据 exp 表达式推导出变量的类型,跟=右边的 value 没有关系。 所以decltype 不要求初始化
闲话:
auto 将变量的类型和初始值绑定在一起,而 decltype 将变量的类型和初始值分开;虽然 auto 的书写更加简洁,但 decltype 的使用更加灵活。
先来一个简单的例子:
#include <iostream>
using namespace std;
int main()
{
auto n1 = 5;//必须初始化,不然会报错,因为是根据初始值推导出变量的类型的
decltype(10)n2;//没有初始化,可以不初始化,因为是根据()里面的内容推导出来的类型
decltype(10)n3 = 100;//初始化了。
auto str1 = "Gentle";
decltype(str1) str2 = "QQ845264718";
cout << "Hello world" << endl;
}
查看变量们的类型:
类型推导对对 cv 限定符的处理
「cv 限定符」是 const 和 volatile 关键字的统称:
- const 关键字用来表示数据是只读的,也就是不能被修改;
- volatile 和const 是相反的,它用来表示数据是可变的、易变的,目的是不让 CPU 将数据缓存到寄存器,而是从原始的内存中读取。
注意:
在推导变量类型时,auto 和 decltype 对 cv 限制符的处理是不一样的。decltype 会保留 cv 限定符,而 auto 有可能会去掉 cv 限定符。
auto 关键字对 cv 限定符的推导规则:
- 如果表达式的类型不是指针或者引用,auto 会把 cv 限定符直接抛弃,推导成 non-const 或者 non-volatile 类型。
- 如果表达式的类型是指针或者引用,auto 将保留 cv 限定符。
类型推导关键字对const限定符的推导例子:
#include <iostream>
using namespace std;
int main()
{
//非指针非引用类型
const int n1 = 100;
auto n2 = 10;
n2 = 99;
decltype(n1) n3 = 20;
//n3 = 5; 这里会报错:不能给常量赋值 表达式必须是可以修改的左值 证明:n3 是 const int 类型,跟n1类型一致。
//指针类型 指向常量的指针 指针指向可以改,指针指向的值不可以改
const int *p1 = &n1;
auto p2 = p1;
//*p2 = 66; 这里会报错:不能给常量赋值 表达式必须是可以修改的左值 证明p2 的类型和p1一样是 const int*。
decltype(p1) p3;
//*p3 = 19; 这里会报错:不能给常量赋值 表达式必须是可以修改的左值 证明p3 的类型和p1一样是 const int*。
cout << "hello world" << endl;
}
对变量们类型的查看:
这里可以验证,类型推导对指针类型cv 限定符的推导规则。
类型推导关键字对引用推导
例子:
#include <iostream>
using namespace std;
int main()
{
int n = 10;
int &r1 = n;
//auto推导
auto r2 = r1;
r2 = 20;
cout << "n = " << n << ", r1 = " << r1 << ", r2 = " << r2 << endl;
//decltype推导
decltype(r1)r3 = n;
r3 = 99;
cout << "n = " << n << ", r1 = " << r1 << ", r3 = " << r2 << endl;
cout << "hello world" << endl;
}
查看变量们的类型:
总结:
可以看出来auto把引用抛弃了,decltype则保留了引用。
闲谈:auto 虽然在书写格式上比 decltype 简单,但是它的推导规则复杂,有时候会改变表达式的原始类型;而 decltype 比较纯粹,它一般会坚持保留原始表达式的任何类型,让推导的结果更加原汁原味。
详细关于auto
decltype的具体用法
decltype的由来
既然已经有了 auto 关键字,为什么还需要 decltype 关键字呢?因为 auto 并不适用于所有的自动类型推导场景,在某些特殊情况下 auto 用起来非常不方便,甚至压根无法使用,所以 decltype 关键字也被引入到 C++11 中。
用法:
decltype(exp) varname; //不初始化
decltype(exp) varname = value; //初始化
其中,varname 表示变量名,value 表示赋给变量的值,exp 表示一个表达式。
exp 注意事项
原则上讲,exp 就是一个普通的表达式,它可以是任意复杂的形式(如函数),但是我们必须要保证 exp 的结果是有类型的,不能是 void;例如,当 exp 调用一个返回值类型为 void 的函数时,exp 的结果也是 void 类型,此时就会导致编译错误。
decltype 简单用法的例子:
#include <iostream>
using namespace std;
int main()
{
int a = 0;
decltype(a) b = 1;
decltype(9.9) x = 1.1;
decltype(x + 100) y;
cout << "hello world" << endl;
}
然后查看一下变量们的类型
decltype 推导规则
decltype它的玩法实际上可以非常复杂。当程序员使用 decltype(exp) 获取类型时,编译器将根据以下三条规则得出结果:
- 如果 exp 是一个不被括号( )包围的表达式,或者是一个类成员访问表达式,或者是一个单独的变量,那么 decltype(exp) 的类型就和 exp 一致,这是最普遍最常见的情况。
- 如果 exp 是函数调用,那么 decltype(exp) 的类型就和函数返回值的类型一致。
- 如果 exp 是一个左值,或者被括号( )包围,那么 decltype(exp) 的类型就是 exp 的引用;假设 exp 的类型为 T,那么 decltype(exp) 的类型就是 T&。
exp为普通表达式的例子:
#include <iostream>
using namespace std;
class Student
{
public:
static int total;
string name;
int age;
float scores;
};
int main()
{
int n = 0;
const int &r = n;
Student Stu;
decltype(n) a = n; //n为int类型,a被推导为int类型
decltype(r) b = n; //r为const int&类型,b被推导为const int&类型
decltype(Stu) stu = Stu; //Stu为Student类型,stu被推导为Student类型
decltype(Student::total) c = 0; //Student::total为Student的一个int类型变量,c被推导为int类型
//Stu.name为Student的一个string类型,所以url被推导为string类型
decltype(Stu.name) ur1 = "https://blog.csdn.net/weixin_50188452?spm=1001.2014.3001.5343";
}
查看变量们的类型:
对应推导规则 1,对于一般的表达式,decltype 的推导结果就和这个表达式的类型一致。
exp 为函数调用的例子:
#include <iostream>
using namespace std;
int func1(string, double);//返回值为int 类型
int& func2(int); //返回值为int& 类型
int&& func3(void); //返回值为int&&类型
const int func4(float); //返回值为const int 类型
const int& func5(int);//返回值为const int& 类型
const int&& func6(bool); //返回值为const int&& 类型
int main()
{
int n = 10;
decltype(func1("hello", 3.14)) a; //函数func1的返回值是int类型,所以a被推导为int类型
decltype(func2(3)) b = n; //函数func2的返回值是int&类型,所以b被推导为int&类型
decltype(func3()) c = 0;//函数func3的返回值是int&&类型,所以c被推导为int&&类型
decltype(func4(9.9)) d = 100;//函数func4的返回值是const int类型,d被推导为int类型(特例)
decltype(func5(9)) e = d;//函数func5的返回值是const int&类型,所以e被推导为const int&类型
decltype(func6(true)) f = 0;//函数func6的返回值是const int&&类型,所以f被推导为const int&&类型
cout << "hello world" << endl;
}
查看变量的类型,发现了一个特例
注意:exp 中调用函数时需要带上括号和参数,但这仅仅是形式,并不会真的去执行函数代码。这里对应这规则2
exp 是左值,或者被( )包围的例子:
#include <iostream>
using namespace std;
class Base
{
public:
int x;
};
int main()
{
const Base obj;
decltype(obj.x) a = 0; //不带括号,符合推导规则1,所以推导为int
decltype((obj.x)) b = a;//带括号,符合推导规则3,所以推导为const int&
int n = 5, m = 10;
decltype(n + m) c = 0; //n+m得到右值,符合规则1,所以推导为int
decltype(n = n + m) d = c; //n = n+m得到左值,符合推导规则3,所以推导为int&
cout << "hello world" << endl;
}
查看一下变量们的类型:
这里对应着推导规则3。
补充左值和右值的理解:
左值是指那些在表达式执行结束后依然存在的数据,也就是持久性的数据;右值是指那些在表达式执行结束后不再存在的数据,也就是临时性的数据。有一种很简单的方法来区分左值和右值,对表达式取地址,如果编译器不报错就为左值,否则为右值。
decltype 的实际应用
应用于模板类型编程中的例子:
#include <iostream>
#include<vector>
using namespace std;
template <typename T>
class Base
{
public:
void func(T& container)
{
m_it = container.begin();
}
private:
//typename T::iterator m_it; //一起处理会报错
//typename T::const_iterator m_it; //在之前的 C++98/03 版本下只能想办法把 const 类型的容器用模板特化单独处理
decltype(T().begin()) m_it; //C++11的做法,一起处理
};
int main()
{
const vector<int> v;
Base<const vector<int>> obj;
obj.func(v);
cout << "hello world" << endl;
system("pause");
return 0;
}
红色
红色
以上是关于C++11类型推导的关键字auto和decltype的主要内容,如果未能解决你的问题,请参考以下文章