c++11：auto和decltype（自动类型推导）

auto：自动类型推导，编译器会在编译期间自动推导出变量的类型，这样我们就不用手动指明变量的数据类型。

• auto 必须要初始化
• auto只是一个占位符，在编译期间才会推导出来

auto和const一起使用：

• 当类型不为引用时，auto 的推导结果将不保留表达式的 const 属性；
• 当类型为引用时，auto 的推导结果将保留表达式的 const 属性。

 

auto不能使用的地方：

• 不能在函数的参数中使用
• 不能定义数组
• 不能作用于模板参数（类模板需要指定参数）
• 不能作用于类的非静态成员变量

 不能在函数的参数中使用

 

不能定义数组 

 

不能作用于模板参数（类模板需要指定参数） 

 

不能作用于类的非静态成员变量 

 

 auto的常见用法：

数组和容器的遍历：

#include<iostream>
using namespace std;
#include<vector>
int main()
{ 
	int p[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (auto i : p)
	{
		cout << i <<" ";
	}
	cout << endl;
	vector<int>p1(10, 1);
	for (auto j : p1)
	{
		cout << j << " ";
	}
	cout << endl;
	system("pause");
	return 0; 
}

 

STL中的使用：

	vector<int>p2(10, 1);
	vector<int>::iterator n= p2.begin();
	auto n1 = p2.begin();//推导迭代器类型

decltype类型推导

decltype的格式为：decltype(X)  name =data;

decltype数据类型是根据X来推导的，而不是根据data

• X 可以为一个值，也可以为表达式，也可以为函数，但必须要有类型，不能为void
• 当X为一个函数时，并不会执行该函数，只会获取返回类型

int text()
{
	return 1;
}
void text1(){}
void text2(){}
int main()
{ 
	decltype(10) name = 12.1;
	decltype(10 + 1.0) name1 = 10;
	decltype(text()) name2 = 20;
	decltype(text1)name3= text2();//编译错误无法初始化
	name3 = text2();//name3不可修改
	system("pause");
	return 0; 
}

decltype左值右值的区别：

• 如果为（左值），那么数据类型为该值的引用
• 如果为（右值），那么数据类型和该值相同
• 如果为（指针），那么数据类型为该指针的引用

	int i = 10;
	int j = 20;
	decltype(i)p;//i为右值，数据类型为int
	decltype((i))p1=i;//（i）为左值，数据类型为int&，
	decltype(i = i + j)p2=i;//i=i+j为左值，数据类型为int&
    int* n = &i;
	decltype(*n)p3=i;//*n为指针，数据类型为int&

（）和（（））的区别：

• （）单层括号就直接获取里面数据的数据类型
• （（））双层括号：编译器会把括号里面的数据当成一个表达式，是左值，所以结果永远都是引用。

decltype的常见用法：

在泛型编程中

template<class T>
class person
{
	typename T::iterator pt;//迭代器
	//T:iterator 无法包括所有的迭代器（const_iterator）
	//在c++11之前，是把const_iteartor 分开编写

	//c++11之后可以使用 decltype自动类型推导
	decltype(T().begin()) pa;
public:
	void gettext(T& k)
	{
		pt = k.begin();//报错，无法转换为const_iterator
	}
	void gettext1(T& k)
	{
		pa = k.begin();//可以运行
	}
};
int main()
{ 
	const vector<int> p;
	person<const vector<int>> p2;
	p2.gettext(p);
	p2.gettext1(p);
	system("pause");
	return 0; 
}

在函数中的使用;

c++11可以使用尾置返回类型（auto和decltype的联合使用）又称跟踪返回类型。

格式为：

template<class T1,class T2>
auto add(T1 n, T2 m)->decltype(n + m)
{
	return n + m;
}

跟踪返回类型：decltype会跟踪（）里面的数据类型，然后把数据类型传递给auto

template<class T1,class T2>
auto add(T1 n, T2 m)->decltype(n + m)
{
	return n + m;
}
int main()
{ 
	cout << add(12.5, 10) << endl;
	cout << add(12, 10) << endl;
	system("pause");
	return 0; 
}