110 C++ decltype含义，decltype 主要用途

一，decltype 含义和举例

decltype有啥返回啥，auto则不一样，auto可能会舍弃一些东西。

decltype 是 C++11提出的说明符。主要作用是：返回操作数的数据类型。  

decltype 是用来推导类型，decltype对于一个给定的 变量名或者表达式，能推导出类型

这和auto 有啥区别呢？

auto a =10; 我们用10这个表达式 赋值给 a，那么auto 就能推断出来 a 是int，auto本身也是auto。也就是说，auto 必须初始化 获得这个值，才能知道具体的类型。

现在我们并不希望使用一个具体的值或者表达式 来对a进行初始化，那么怎么知道a 的类型呢？

decltype 就派上用场了。

decltype 特点：

        1.decltype 的自动类型推断会发生在编译器（和auto 一样）

        2.decltype 不会真正计算表达式的值。

decltype 后的圆括号中是个变量

        const int i =0;

        const int &iy = i;

        auto j1 = i; //auto 的传值方式，i 的引用属性和const属性都会被抛弃。j1 = int， auto = int 

        decltype(i) j2 = 15; //如果decltype 中是一个变量，则变量中的const 属性会保留, j2 = const int

        decltype(iy) j3 = j2;//如果decltype中是一个变量，则变量中的const属性，引用属性，都会保留，因此 j3 = const int &

        decltype 是很循规蹈矩的，有啥就返回啥。

class Teacher{

public:

int i ;

}

decltype(Teacher::i) a;//会推导出 a = int

Teacher tea;

decltype(tea) tea2;// 会推导出 tea2 = Teacher

decltype(tea.i)  mv_i;//会推导出 mv_i的类型是 int

int x =1；y=2;

auto &&z = x; // z 是万能引用，那么先要看x 是啥，x 是左值，万能引用并不是一种真正的类型，万能引用要不是左值引用，要不是右值引用， 万能引用只是一个概念，因此z 是一个 左值引用 int &， auto也是一个int &

auto &&zz = 100; // z 是万能引用，那么先要看后面传进来的值是啥，是100,100是个右值，因此zz就是 右值引用 int &&， auto 是一个int。

decltype(z) && h = y; //z是一个万能引用，其本质是一个左值引用，因此 h = & && ，引用折叠发挥作用，因此h 是一个 左值引用

decltype(z) & h1 = y; //z是一个万能引用，其本质是一个左值引用，因此 h1= & & ，引用折叠发挥作用（只要有一个是左值引用，就是左值引用），因此h1 是一个 左值引用。

decltype(zz) && h2 = 100;//zz是一个万能引用，其本质是一个右值引用，因此 h2 = && &&，引用折叠发挥作用，（两个都必须是右值引用，才是右值引用），因此h2是右值引用，注意的是给如果写成 decltype(zz) && h2 = y; 就会有build error，这是因为h2是右值引用，只能绑定右值，但是y是左值。

例子：

void main() {
	//decltype 知识点
	//decltype 是 C++11提出的说明符。主要作用是：返回操作数的数据类型。  
	//1 decltype 括号里面是一个变量
	int a = 10; //普通
	int *pa = &a;//指针
	int &yinyonga = a;//左值引用
	decltype(a) b;
	using boost::typeindex::type_id_with_cvr;
	cout << "b = " << type_id_with_cvr<decltype(b)>().pretty_name() << endl; //结果是int

	decltype(pa) b1;
	cout << "b1 = " << type_id_with_cvr<decltype(b1)>().pretty_name() << endl; //结果是int *

	int c = 30;
	double d = 80.8;
	decltype(yinyonga) b2 = c; //很显然b2是一个左值引用，左值引用必须绑定左值
	cout << "b2 = " << type_id_with_cvr<decltype(b2)>().pretty_name() << endl; //结果是int &

	//decltype(yinyonga) b3 = d; //build error, b3 是 int&，是需要绑定在一个int 的左值上的，d是double类型的左值，因此有build error
	//cout << "b3 = " << type_id_with_cvr<decltype(b3)>().pretty_name() << endl; //结果是int &

	decltype(a) *wnyy1;
	cout << "wnyy1 = " << type_id_with_cvr<decltype(wnyy1)>().pretty_name() << endl; 
	//decltype 会将a变成 int，因此 wnyy1是int *

	decltype(pa) *wnyy2;
	cout << "wnyy2 = " << type_id_with_cvr<decltype(wnyy2)>().pretty_name() << endl;
	//decltype 会将pa变成 int *，因此 wnyy2是int **

	//decltype(yinyonga) *wnyy3;//不允许使用指向 引用的指针

	int a1 = 80909;
	decltype(a) &wnyy4 = a1;
	cout << "wnyy4 = " << type_id_with_cvr<decltype(wnyy4)>().pretty_name() << endl;
	//decltype 会将a变成 int ，因此 wnyy4是int &

	decltype(pa) &wnyy5 = pa;
	cout << "wnyy5 = " << type_id_with_cvr<decltype(wnyy5)>().pretty_name() << endl;
	//decltype 会将pa变成 int * ，因此 wnyy5是int *&

	int &yingyonga2 = a;
	decltype(yinyonga) &wnyy6 = yingyonga2;
	cout << "wnyy6 = " << type_id_with_cvr<decltype(wnyy6)>().pretty_name() << endl;
	//decltype 会将yinyonga变成 int&  ，按照引用折叠规则，因此 wnyy6是int &

	int && youzhiyinyonga = 231;
	decltype(youzhiyinyonga) &wnyy7 = yingyonga2;
	cout << "wnyy7 = " << type_id_with_cvr<decltype(wnyy7)>().pretty_name() << endl;
	//decltype 会将youzhiyinyonga变成 int&&  ，按照引用折叠规则，因此 wnyy7是int &

	decltype(youzhiyinyonga) &&wnyy8  = 90;
	cout << "wnyy8 = " << type_id_with_cvr<decltype(wnyy8)>().pretty_name() << endl;
	//decltype 会将youzhiyinyonga变成 int&&  ，按照引用折叠规则，因此 wnyy8是int &&

	decltype(yingyonga2) && wnyy9 = yinyonga;
	cout << "wnyy9 = " << type_id_with_cvr<decltype(wnyy9)>().pretty_name() << endl;
	//decltype 会将yingyonga2变成 int&  ，按照引用折叠规则，因此 wnyy9是int &


}

decltype 后的圆括号中非变量（是表达式）

decltype 会返回 表达式的 结果类型。

decltype(8) kkk = 5;//decltype是计算 表达式8的结果类型，也就是 int，因此KKK是int

decltype(8.0) kkk1 = 5;//decltype是计算 表达式8.0的结果类型，也就是 float，因此KKK是float

void main() {
	//decltype 后的圆括号中非变量（是表达式）

	decltype(8) kkk = 5;//decltype是计算 表达式8的结果类型，也就是 int，因此KKK是int
	decltype(8.0) kkk1 = 5;//decltype是计算 表达式8.0的结果类型，也就是 float，因此KKK是float
	using boost::typeindex::type_id_with_cvr;
	cout << "kkk = " << type_id_with_cvr<decltype(kkk)>().pretty_name() << endl; //结果是int
	cout << "kkk1 = " << type_id_with_cvr<decltype(kkk1)>().pretty_name() << endl; //结果是int

	int a = 10;
	int *pa = &a;
	int &yinyonga = a;
	decltype(a + 10) kkk2 = 5;
	cout << "kkk2 = " << type_id_with_cvr<decltype(kkk2)>().pretty_name() << endl; //结果是int
	//kkk2是 int ，由于 a+10这个表达式的结果是int，因此kkk2是int

	decltype(pa + 10) kkk3 ;
	cout << "kkk3 = " << type_id_with_cvr<decltype(kkk3)>().pretty_name() << endl; //结果是int
	//kkk3是 int* ，由于 pa+10这个表达式的结果是int *，因此kkk3是int *

	//decltype(*pa) kkk4 = 88;//会有build error
	int b = 800;
	decltype(*pa) kkk5 = b;//注意这里，会有不同
	cout << "kkk5 = " << type_id_with_cvr<decltype(kkk5)>().pretty_name() << endl; //结果是int
	//kkk5是 int& ，
	//*pa 是指针pa所指向的对象，而且能够给对象赋值，类似 *pa = 800;因此 *pa 是一个左值，
	// *pa除了在定义变量的时候，其他时间都是一个表达式。
	// 注意这句话：如果表达式结果能够作为赋值语句左边的值，那么decltype后返回的就是引用
	//这也是为啥 kkk4 赋值=80的时候，会有build error，因为是int &，需要一个左值，而80是个右值
	//这种情况要专门记一下。
	//整理为：如果decltype后面是一个非变量的表达式，并且表达式能够作为等号左边内容，那么他返回的类型必定一个左值引用


	decltype(yinyonga + 10) kkk6;
	cout << "kkk6 = " << type_id_with_cvr<decltype(kkk6)>().pretty_name() << endl; //结果是int
	//kkk6是 int ，由于 yinyonga+10这个表达式的结果是int ，因此kkk6是int 

	decltype(a) kkk7;
	cout << "kkk7 = " << type_id_with_cvr<decltype(kkk7)>().pretty_name() << endl; //结果是int
	//kkk7是 int ，由于 a是一个变量 ，a是int ，因此kkk7是int 


	decltype((a)) kkk8 = b;
	cout << "kkk8 = " << type_id_with_cvr<decltype(kkk8)>().pretty_name() << endl; //结果是int
	//kkk8是 int &，由于  (a)是一个表达式，注意这里a是变量，(a)是表达式 ，且(a) = 90，是可以赋值的，因此kkk8是int &



}

decltype后的圆括号是个函数

    //decltype后的圆括号是个函数，那么decltype（）括号中的类型为该函数返回类型，但是不会真正的去执行函数，它只会看函数的返回值

void main() {
	//decltype后的圆括号是个函数，那么decltype（）括号中的类型为该函数返回类型，但是不会真正的去执行函数，它只会看函数的返回值
	decltype(func62()) a = 90;

	using boost::typeindex::type_id_with_cvr;
	cout << "a = " << type_id_with_cvr<decltype(a)>().pretty_name() << endl; //结果是int
	// a的类型是int


	decltype(func63(89,90.8)) b = 90000;
	cout << "b = " << type_id_with_cvr<decltype(b)>().pretty_name() << endl; //结果是int
	// b的类型是double

	decltype(func63) c;
	cout << "c= " << type_id_with_cvr<decltype(c)>().pretty_name() << endl; //结果是int
	// c的类型是: double __cdecl(int,double) 有返回值，有参数，是一个可调用对象，注意不是 函数指针
	//如果是函数指针，应该是 double (*)(int,double)
	//如果是函数引用 ，应该是 double (&)(int,double)

	//c的类型是可调用对象，c不是类型
	//需要使用function 类模版来处理
	function<decltype(func63)>  cc2 = func63;
	function<decltype(func63)>  cc3 = func64;
	//function<c>  cc2 = func63;//build error，c是可调用对象，不是类型
	cc2(20, 98.8);
	cc3(98.9,30);
}

二 decltype 主要用途

主要是用于模版编程中。

1.在类模版中应付可变类型

//decltype 主要用途1：在类模版中 应付可变类型。

template <class T>
class Teacher60 {
public:
	typename T::iterator iter;//typename在这里类似重命名，告知 

	void getbegin(T & tmpc) {
		//...
		iter = tmpc.begin();
		//...
	}
};

//类模版偏特化
template <class T>
class Teacher60<const T>{
public:
	typename T::const_iterator iter;

	// typename在这里的含义是：显式地告诉编译器，
	//T::const_iterator是一个类型名。
	//	然后用这 个类型  T::const_iterator 定义一个变量 iter 

	void getbegin(const T & tmpc) {
		//...
		iter = tmpc.begin();
		//...
	}
};

//使用decltype()方法处理，实参传递的是啥，我们就定义啥
template <class T>
class Teacher61{
public:
	decltype(T().begin()) iter;// 使用decltype()指定类型，
	//注意的是 T(),生成临时对象，调用临时对象的begin()函数
	//但是由于被 decltype 包裹，因此不会调用构造函数，也不会调用begin()函数，说白了，decltype（）括号里面是函数，则只是会拿 函数的返回值类型，不会执行函数

	void getbegin(const T & tmpc) {
		//...
		iter = tmpc.begin();
		//...
	}
};

void main() {
	// decltype主要用途1 ，应付可变类型，一般decltype主要用途还是应用于模版编程中
	using conttype = std::vector<int>;
	conttype myarr = { 10,20,30 };
	Teacher60<conttype> ct;
	ct.getbegin(myarr);

	//如果我们将 conttype改成 const std::vector<int>;就会有build error
	//原因是我们对于 const std::vector<int>,需要使用typename T::const_iterator iter 处理
	using conttype1 = const std::vector<int>;
	conttype myarr1 = { 10,20,30 };
	Teacher60<conttype1> ct1;
	ct1.getbegin(myarr1);

	//那么对于这种问题，在C++98时代，需要通过 类模版特例化来实现。
//https://mp.csdn.net/mp_blog/creation/success/135431592

	//在C++11时代，可以通过 decltype 来声明类型，这样就避免了使用类模版特例化处理这些问题

	using conttype2 = const std::vector<int>;
	conttype myarr2 = { 10,20,30 };
	Teacher61<conttype2> ct2;
	ct2.getbegin(myarr2);

}

2.通过变量表达式抽取变量类型

//decltype 主要用途2，通过变量表达式 抽取 变量类型。

void main() {
	vector<int> ac;
	ac.push_back(1);
	ac.push_back(2);
	vector<int>::size_type vsize = ac.size(); //size_type 无符号整数类型（通常是 std::size_t ）

	decltype(ac) bc;//bc 的类型是vector<int>
	using boost::typeindex::type_id_with_cvr;
	cout << "bc = " << type_id_with_cvr<decltype(bc)>().pretty_name() << endl; //结果是int
	//bc = class std::vector<int, class std::allocator<int> >

	decltype(ac)::iterator iter;
	decltype(ac)::size_type vvsize = ac.size();
	cout << "vvsize = " <<vvsize << endl;

}

3.auto 结合 decltype 构成返回 类型后置 语法

//3.auto 结合 decltype 构成返回 类型后置 语法
//先回顾一下之前学的 auto 返回类型后置语法

auto func70(int a, double b) ->int {
	//auto 在这里表示的是  函数返回类型是写在->之后的。
	return 0;
}
//使用decltype 自动推导。a+b的返回值类型是double，因此 auto 是double
auto func71(int a, double b)->decltype(a + b) {
	return a * a + b;
}

//对于同名函数的处理问题

int func72(int & temp) {
	cout << "func72(int & temp)" << endl;
	return temp + 2;
}

double func72(double & temp) {
	cout << "func72(double & temp)" << endl;
	return temp + 2.80;
}

template <typename T>
auto Func73(T & temp)->decltype(func72(temp)) {
	return func72(temp);
}

void main() {
	int i = 90;
	Func73(i);
	double d = 90.8;
	Func73(d);
}

4.decltype(auto)用法 C++14提出

问题：

                用于函数返回类型

decltype(auto)：把auto 理解成要推导的类型，推导过程我们采用decltype

//decltype(auto)一起使用
//先看问题

template <typename T>
T& func80(T& v1) {
	v1 = v1 * 2;
	return v1;
}

template <typename T>
auto& func81(T& v1) {
	v1 = v1 * 2;
	return v1;
}

template <typename T>
auto func82(T& v1) {
	v1 = v1 * 3;
	return v1;
}

//decltype(auto) 会让返回值是啥类型（v1是 T&），那么整个函数的返回值也就是 T&
template <typename T>
decltype(auto) func83(T& v1) {
	v1 = v1 * 4;
	return v1;
}


void main() {
	int a = 100;
	func80<int>(a) = 90000;//func80的返回值是 T&,是个左值，因此赋值，由于func80返回的就是a的引用，因此相当于给a赋值90000
	cout << "a = " << a << endl;

	//下来，我们将func80 返回值auto &
	int b = 80;
	func81<int>(b) = 190000;//func80的返回值是 T&,是个左值，因此赋值，由于func80返回的就是a的引用，因此相当于给a赋值90000
	cout << "b = " << b << endl;

	//下来，我们将func80 返回值auto 
	int c = 80;
	//func82<int>(c) = 190000;//build error, 因为auto 返回的类型是int
	cout << "c = " << c << endl;


	int d = 180;
	func83<int>(d) = 8190000;//使用 decltype(auto)做为返回值
	cout << "d = " << d << endl;

}

                用于变量声明中

	int x = 90;
	const int &y = 80;
	auto z = y; //z的类型是int，因为是值传递，会丢弃 const 和引用
	
	decltype(auto) z1 = y;//z1的类型为const int &

5.再谈 decltype ()中 是变量表达式的情况再讨论

decltype(auto) func85() {
	int a = 90;
	return a;
}

decltype(auto) func86() {
	int aa = 90;
	return (aa);
}

//坑点
void main() {
	//我们观察 func85 和 func86
	//由于func86的返回值 是用()小括号 包裹的，因此会被认为是一个表达式。因此func86的返回值是int&
	//这就有问题了，因为aa是局部变量，出了func86的范围就失效了

}

三 总结