c++ auto学习笔记

一、auto的意义

在C++11中赋予auto的意义是：在声明变量时，根据初始化表达式自动推断该变量的类型。声明函数时作为函数返回值的占位符（用在函数返回类型后置的情况）。

如

auto i = 6; //auto推断为int

auto func()->int //函数返回类型后置，auto作为占位符
{
    return 666;
}

二、使用auto的一些注意事项

1、当使用一个auto声明多个变量时，遵循由左至右的推导规则，以最左边的表达式推导出auto的类型；

int a = 5;
auto *p = &a, b = 10; //由于&a为int*类型，则p为int*类型；auto推导为int, b为int型变量

2、可以使用条件表达式初始化auto声明的变量，且当条件的值类型不同时，编译器总是使用表达能力更强的类型作为auto的推导类型；

auto i = true ? 5 : 10.0; //由于5为int型，10.0为double型，编译器会将auto推导为double

3、auto无法声明非静态成员变量

三、推导规则

1、如果auto声明的变量按值初始化，则推导出的类型会忽略初始化表达式的cv限定符（const和volatile限定符）、引用属性。但是指针属性会保留；

const int a = 5; //a为const int类型变量
auto b = a; //auto推导为int, b为int型变量，const属性被忽略

int c= 8;
int &e = c; //e为int&类型
int &&f = 8; //f为int&&类型
auto i = e; //auto推导为int，忽略了左值引用的属性
auto j = f; //auto推导为int，忽略了右值引用的属性

int *p = &c; //p为int*类型
auto pp = p; //auto推导为int*

2、 对于auto&声明的变量，无论初始值是什么类型，该变量都会被推导为对应的左值引用类型，且会保留cv属性；

int a = 1;   //a是int型，左值
int &b = a;  //b是int&型，左值引用
int &&c = 3; //c是int&&型，右值引用
const int d = 7; //d是const int型

auto &m = a; //m被推导为int&, auto->int
auto &m = b; //m被推导为int&, auto->int
auto &m = c; //m被推导为int&, auto->int
auto &m = d; //m被推导为const int&，auto->const int
auto &m = 888; //error,无法编译通过，左值引用不能引用右值

3、对于auto&&声明的变量，导为左值引用类型；如果初始值是右值，该变量将会被推导为右值引用类型。同样的，也会保留cv限定符；

这里2,3点使用了引用折叠规则，可以参考这篇文章。

C++万能引用和完美转发_星星典典的博客-CSDN博客

int a = 1;   //a是int型，左值
int &&c = 3; //c是int&&型，右值引用
const int d = 7; //d是const int型

auto &&m = a; //m被推导为int&
auto &&m = c; //m被推导为int&。注意：c虽然是右值引用类型，用于引用右值，但是c本身是具名对象，是左值
auto &&m = d; //m被推导为const int&，auto->const int
auto &&m = 888; //888是右值，所以m被推导为int&&

4、使用auto声明变量时，如果初始化对象是一个数组或者是函数，则auto会被推导为对应的指针类型。

int arr[5];
void func(int){}

auto ap = arr; //ap被推导为int*类型
auto fp = func; //fp被推导为void(__cdecl *)(int)类型

三、auto的常见用处

1、当我们一眼就能看出变量的初始化类型，为了简化代码，常常使用auto声明变量；

例如在for循环中遍历std::map，见如下代码。

如果不使用auto，我们就要使用std::map<std::string, int>::const_iterator来声明it。但是这并不会有什么好处，反而让代码读起来有点困难。

void func(std::map<std::string, int> data_map)
{
    for(const auto& it : data_map)
    {
        std::cout << it.first << "value: " << it.second << std::endl;
    }
}

2、对于比较复杂的返回类型，例如lambda表达式、band等可以使用auto；

例如

int main()
{
	auto func = [](int a, int b)
	{ std::cout << a + b << std::endl; };
	func(1, 2);
	func(3, 4);
}

对于lambda表达式func的类型，我们无法准确写出。好在我们无需关注lambda表达式的类型，直接使用auto声明就好。

3、作为函数返回值，支持返回类型的推导

C++14支持对对函数返回类型声明为auto的推导，所以我们可以这样使用auto：

auto sum(int a, int b){return a+b;}

很明显，函数sum的返回值将被推导为int。

但是，如果返回值可能存在多种情况时，必须返回值类型要保持一致。

例如，将sum写成如下这样，会发生编译错误。

auto sum(int a, int b)
{
	if (a < 0 && b < 0)
		return std::string("error");
	return a + b;
}

4、将auto作为lambda表达式的形参

如下代码所示，2个形参都是auto。在使用时a被推导为int，b被推导为double。在没指定返回值类型的情况下，返回值类型将被推导为表达能力更强的double。

注意，具名函数不可以将形参声明为auto。如果也想声明一个泛式的具名函数，可以使用模板函数的方法实现。

int main()
{
	auto sum2 = [](auto a, auto b)
	{ return a + b; };

	std::cout << sum2(1, 3.4);
}

5、将auto&作为lambda的返回类型，可以通过推导返回引用类型

正常情况下，在后置返回类型中不可以使用auto，例如上面第3点中的具名函数sum，可以将auto作为前置返回类型，但是不可以后置。

但是人们发现，这种方法是可以让lambda表达式通过推导返回引用类型的唯一方式。

int main()
{
	auto sum2 = [](auto &a, auto b) -> auto &
	{ 
		a = a + b; 
		return a; };
	int a = 1;
	std::cout << "&a= " << &a << "   &sum2 =" << &sum2(a, 3.4);
}