【C++】3-1.11 c++11自动类型推导关键字 auto

青旅半醒 2022-11-16 01:46 206阅读 0赞

### 【C++】3-1.11 c++11自动类型推导关键字 auto ###

*  背景
 *  关键字 auto
 *  auto的使用说明
 *  auto的总结

# 背景 #

c++11对c++03的增强，使得c++具有“现代（c++11之前成为经典c++）”的特点，  
其特点之一就是由auto和decltype构成的自动类型推导系统。  
本博客只介绍auto的常见用法。

# 关键字 auto #

C++03及之前的标准中，auto放在变量声明之前，声明变量的存储策略。但是这个关键字常省略不写。  
C++11中，将auto关键字重用，改变auto原来的含义：  
auto关键字放在变量之前，作用是在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型；

如下示例：

#include <iostream>
    #include <string>
    int main() 
    { 
    	int num1 = 10010537;
    	auto num2 = num1;                             //自动类型推导；
    	std::cout << typeid(num2).name() << std::endl;//输出 int
    	
    	std::cin.get();
    	return 0;
    }

# auto的使用说明 #

**1.auto 变量必须在定义时初始化，这类似于const关键字**  
因为它是根据变量初始值的类型，进行类型推断！

#include <iostream>
    #include <string>
    int main() 
    { 
    	auto num1 = 10010537; //自动类型推导；推导为int
    	std::cout << typeid(num1).name() << std::endl;//输出 int
    
    
    	//以下是定义时，未初始化，编译器无法推导num2的类型，所以编译会报错 
    	auto num2;
    	num2=10010536;		
    	
    	std::cin.get();
    	return 0;
    }

编译报错如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70]

**2、定义在一个auto序列的变量必须始终推导成同一类型**  
即使用auto在一行定义多个变量时，一行为同一类型；  
注意：不能同时使用直接和拷贝列表初始化！要么都是直接列表初始化，要么都是拷贝列表初始化！

#include <iostream>
    int main() 
    { 
    	auto num1 = 10010537, num2= 10010536; //自动类型推导；推导为int
    	std::cout << typeid(num1).name() << std::endl;//输出 int
    	std::cout << typeid(num2).name() << std::endl;//输出 int
    
    	//错误,没有推导为同一类型 
    	auto num3{  100 }, num4 = 100.0;
    	
    	std::cin.get();
    	return 0;
    }

编译报错如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 1]

**3、如果初始化表达式是引用或const，则去除引用或const语义。**  
即auto推导忽略&和const

#include <iostream>
    int main() 
    { 
    	int num1 = 10010537;
    	int& num2 = num1; //初始化一个引用num2
    	std::cout <<"[1] "<< typeid(num2).name() << std::endl;//输出 int
    	
    	auto num3 = num2;   //num3的类型为int而非int&（去除引用）
    	std::cout << "[2] " << typeid(num3).name() << std::endl;//输出 int
    	
    	num3 = 537;
    	std::cout << "[3.1] " << num1 << std::endl;//输出 int
    	std::cout << "[3.2] " << num2 << std::endl;//输出 int
    	std::cout << "[3.3] " << num3 << std::endl << std::endl;//输出 int
    	
    	const int num4=100;	
    	auto num5 = num4;    //num5的类型为int而非const int（去除const） 
    	num5 = 200;
    	std::cout << "[4.1] " << typeid(num4).name() << std::endl;//输出 int
    	std::cout << "[4.2] " << typeid(num5).name() << std::endl;//输出 int
    	std::cout << "[4.3] " << num5 << std::endl;//输出 int
    
    	std::cin.get();
    	return 0;
    }

运行如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 2]

**4、 如果auto关键字带上&号，则不去除引用或const语意**  
auto&可以理解成引用，即推导的数据类型与变量初始值的类型一致！  
注意：常量只能读，不能写；

#include <iostream>
    int main()
    { 
    	int num1 = 10010537;
    	int& num2 = num1; //初始化一个引用num2
    	std::cout << "[1] " << typeid(num2).name() << std::endl;//输出 int
    
    	auto& num3 = num2;   //num3的类型为int&（保留引用）
    	std::cout << "[2] " << typeid(num3).name() << std::endl;//输出 int
    
    	num3 = 537;
    	std::cout << "[3.1] " << num1 << std::endl;//输出 int
    	std::cout << "[3.2] " << num2 << std::endl;//输出 int
    	std::cout << "[3.3] " << num3 << std::endl << std::endl;//输出 int
    
    	const int num4 = 100;
    	auto& num5 = num4;    //num5的类型为const int（保留const） 
    	//num5 = 200; 会编译报错，因为num5是const int,所以不能更改num5
    	std::cout << "[4.1] " << typeid(num4).name() << std::endl;//输出 int
    	std::cout << "[4.2] " << typeid(num5).name() << std::endl;//输出 int
    
    	std::cin.get();
    	return 0;
    }

运行如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 3]

**5、初始化表达式为数组时，auto关键字推导类型为指针。**  
数组名字，即代表数组的首地址；这里数组名称退化为指针；  
注意申明数组时，目前不能采用auto array\[\] = \{ 1,2,3 \};

#include <iostream>
    int main()
    { 
    	int array1[3] = {  1, 2, 3 };//int array1[] = { 1, 2, 3 };会编译报错，
    	auto array2 = array1;
    	std::cout << "[1] " << typeid(array1).name() << std::endl;//输出 int [3]
    	std::cout << "[2] " << typeid(array2).name() << std::endl;//输出 int * __ptr64
    
    	std::cin.get();
    	return 0;
    }

运行如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 4]

**6、若表达式为数组且auto带上&，则推导类型为数组类型。**  
auto&可以理解成引用，即推导的数据类型与变量初始值的类型一致！

#include <iostream>
    int main()
    { 
    	int array1[3] = {  1, 2, 3 };
    	auto& array2 = array1;
    	std::cout << "[1] " << typeid(array1).name() << std::endl;//输出 int [3]
    	std::cout << "[2] " << typeid(array2).name() << std::endl;//输出 int [3]
    
    	std::cin.get();
    	return 0;
    }

运行如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 5]

**7、C++14中，auto可以作为函数的返回值类型和参数类型**  
函数的返回值、涉及参数类型都可以使用auto进行自动类型推断；

//vs2019，c++17标准；
    #include <iostream>
    //#include<typeinfo>//使用typeid，可以不导入这个头文件了；
    
    // 定义一个求最大值的函数
    auto max(int x, int y)
    { 
    	return x > y ? x : y;
    }
    
    int main()
    { 
    	//int max(int, int);//如果将max函数写到mian函数下面，需要申明max函数给编译器，且申明max前不能使用auto
    		
    	int re1;
    	re1=max(5, 6);
    	std::cout << "[1] " << re1 << std::endl;
    	
    	auto re2 = max(5, 6);
    	std::cout << "[2] " << typeid(re2).name() << std::endl;//输出 int [3]
    	
    	std::cin.get();
    	return 0;
    }

运行如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 6]

# auto的总结 #

建议尽量使用auto关键字  
可以提高代码的正确性、性能、可维护性、健壮性 … …  
比如：auto关键字保证在声明变量时即初始化变量；

如果希望在定义变量的时候，明确指出类型，此时使用auto可以采用如下方式：

auto x1 = int { 1};  // 初始化列表
    auto x2 = int { 1.0}; // 编译器报错，初始化列表不能窄化
    auto x3 = int (1.0);  // C风格的强制类型转换，x3的值是整数1

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70]: /images/20221022/50f5268fa1e04a4cb0568d269ba2af45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 1]: /images/20221022/b64945fdb06e4296b31fa8118f9a3cbc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 2]: /images/20221022/810f590a1c5646999fd28ff7c082a89c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 3]: /images/20221022/c0664b315c654bcf87f4eff19bd89929.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 4]: /images/20221022/c8331acf16794e73b12e0cc7f6c5455e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 5]: /images/20221022/de342c0525d34f89965bcdcbc4c16cf6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2puMTAwMTA1Mzc_size_16_color_FFFFFF_t_70 6]: /images/20221022/846732fdf2594dd8b71dd4046be0f256.png