C++中auto关键字的用法详解_c++ auto

1.简介

auto作为一个C语言就存在的关键字，在C语言和C++之间却有很大区别。

在C语言中auto修饰的变量，是具有自动存储器的局部变量，但因为局部变量默认类别默认是auto修饰导致一直没有人去使用它。

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一 个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

而这就意味着auto定义变量时必须对其进行初始化

int TestAuto()
{
	return 10;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

编译结果：

注：

使用 auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto 的实际类型。因此auto并非是一种**“类型”的声明，而是一个类型声明时的“占位符”**，编译器在编译期会将auto****替换为变量实际的类型。

2.auto使用细则

1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须 加&

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    *a = 20;
    *b = 30;
     c = 40;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译

器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TestAuto()
{
    auto a = 1, b = 2; 
    auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
1
2
3
4
5

3. auto不能推导的场景

1. auto不能作为函数的参数

因为编译器无法对a的实际类型进行推导

2. auto不能直接用来声明数组
3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
4. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有 lambda表达式等进行配合使用。

4.auto的好处

在C++中因为类，命名空间等语法会出现如std::map<std::string, std::string>::iterator这样的特别长的类别，若单纯用typedef来简略代码则会出现新的麻如：

typedef char* pstring;
int main()
{
 const pstring p1;    // 编译成功还是失败？
 const pstring* p2;   // 编译成功还是失败？
 return 0;
}
1
2
3
4
5
6
7

所以auto无疑是十分不错的选择

5、auto在C++14和C++17的更新

C++的auto关键字最初在C++11中引入，主要用于自动类型推导，使编程更简洁。在后续的C++14和C++17标准中，对auto的使用进行了一些扩展和更新，进一步提高了其灵活性和功能性。下面详细介绍这些更新：

C++14中对auto的更新

1. 返回类型推导:
   在C++14中，auto可以用于推导普通函数的返回类型。这意味着你可以在函数定义时使用auto关键字指定返回类型，编译器会根据返回语句推导出具体的类型。这样做可以增加代码的可读性和灵活性，特别是在模板编程和使用lambda表达式时。

   示例：

   template<class T>
   auto add(T x, T y) {
       return x + y;
   }
   1
   2
   3
   4

2. 泛型Lambda表达式:
   虽然Lambda表达式在C++11中就已经支持，但在C++14中增强了Lambda的能力，允许使用auto关键字作为参数类型，从而创建泛型Lambda。这样的Lambda可以接受任何类型的参数，提高了代码的复用性。

   示例：

   auto genericAdd = [](auto x, auto y) {
       return x + y;
   };
   1
   2
   3

C++17中对auto的更新

1. 类成员初始化:
   C++17允许在类中使用auto关键字来声明成员变量，并通过构造函数列表初始化语法或默认成员初始化器来推导类型。这提供了一种更为灵活的方式来初始化类成员，特别是当类型表达式较为复杂或冗长时。

   示例：

   struct Example {
       auto value = 42;  // 自动推导为int
   };
   1
   2
   3

2. 模板参数推导:
   C++17引入了模板参数推导，这意味着在使用模板时不再总是需要显式指定模板参数。对于函数模板，如果使用auto来指定参数类型，编译器可以根据传递的实参推导出模板参数类型。

   示例：

   template<auto value> void printValue() {
       std::cout << value << std::endl;
   }
   
   int main() {
       printValue<42>();       // 输出: 42
       printValue<'A'>();      // 输出: A (字符'A'的ASCII值)
   }
   
   1
   2
   3
   4
   5
   6
   7
   8
   9

   template<typename T, auto N>
   T fixed_multiply(T val) {
       return val * N;
   }
   
   int main() {
       auto result = fixed_multiply<int, 5>(2); // 输出: 10
       std::cout << result << std::endl;
   }
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

   在这个例子中，fixed_multiply函数模板接受一个类型为T的值和一个auto类型的常量N，然后返回乘积。在实例化时，N的类型会根据提供的常量自动推导。

3. 结构化绑定:
   C++17还引入了结构化绑定，这允许使用auto来解构数组、结构体和tuple，从而更容易地访问复合数据类型的元素。

   示例：

   std::pair<int, double> p = {1, 2.3};
   auto [x, y] = p;  // x是int, y是double
   1
   2

这些更新让auto在C++中的应用更加广泛和灵活，尤其是在编写模板代码或者处理复杂类型时，大大简化了代码的编写。