C++：auto关键字(C++11)、基于范围的for循环(C++11)

---

auto简介

在早期C/C++中auto的含义是:使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它。

• 这是因为在C语言中使用auto关键字声明一个变量为自动变量，是C语言中应用最广泛的一种类型，在函数内定义变量时，如果没有被声明为其他类型的变量都是自动变量，也就是说，省去类型说明符auto的都是自动变量。这里的其他类型指的是变量的存储类型即：静态类型变量（static ）、寄存器类型变量（register）和外部类型变量（extern）。

C++11中，标准委员会赋予了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;//int
	cout << typeid(c).name() << endl;//char
	cout << typeid(d).name() << endl;//int
	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0; 
}

注意：

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

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;//int *
     cout << typeid(b).name() << endl;//int *
     cout << typeid(c).name() << endl;//int
     
     *a = 20;//x == *a == *b == c == 20
     *b = 30;//x == *a == *b == c == 30
     c = 40; //x == *a == *b == c == 40
     
     return 0;
}

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

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

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

auto不能推导的场景

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

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导 
void TestAuto(auto a)
{}

2. auto不能直接用来声明数组

  void TestAuto()
{
    int a[] = {1,2,3};
	//auto b[] = { 4,5,6 };//auto不能直接用来声明数组
}

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
4. auto在实际中最常见的优势用法就是C++11提供的新式for循环，还有lambda表达式等进行配合使用。
5. auto不能定义类的非静态成员变量
6. 实例化模板时不能使用auto作为模板参数

范围for的语法

在C++98中如果要遍历一个数组，可以按照以下方式进行:

#include <iostream>
using namespace std;

void TestFor()
{
     int array[] = { 1, 2, 3, 4, 5 };
     for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
         array[i] *= 2;
     for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
         cout << *p << " "; //2 4 6 8 10
}

int main(){
     TestFor();
     return 0;
}

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ :”分为两部分:第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor()
{
     int array[] = { 1, 2, 3, 4, 5 };
     for (auto& e : array)
         e *= 2;
         
     for (auto e : array)
         cout << e << " ";//2 4 6 8 10
	
	return 0;
}

与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

范围for的使用条件

1. for循环迭代的范围必须是确定的

对于数组而言，就是数组中第一个元素和最后一个元素的范围;对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
注意:以下代码就有问题，因为for的范围不确定

void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e <<endl;
}

2. 迭代的对象要实现++和==的操作。

习题

1. 下列代码试图打印数字1-9的全排列组合。

#include "stdio.h"
#define N 9
int x[N];
int count = 0;
 
void dump() {
  int i = 0;
  for (i = 0; i < N; i++) {
    printf("%d", x[i]);
  }
  printf("\n");
}
 
void swap(int a, int b) {
  int t = x[a];
  x[a] = x[b];
  x[b] = t;
}
 
void run(int n) {
  int i;
  if (N - 1 == n) {
    dump();
    count ++;
    return;
  }
  for (i = ___; i < N; i++) {
    swap(___, i);
    run(n + 1);
    swap(___, i);
  }
}
 
int main() {
  int i;
  for (i = 0; i < N; i++) {
    x[i] = i + 1;
  }
  run(0);
  printf("* Total: %d\n", count);
}

其中run函数中缺失的部分应该依次为：

A. n+1, n, n+1
B. n+1, n, n
C. n, n, n
D. n, n+1, n+1
E. n+1, n+1, n+1
F. n, n, n+1

正确答案

C

答案解析

这是一道分治算法题。这种循环套递归的题目是很难一下子理解的，因此可以把问题的规模减小。先试 3 个元素，然后我们发现，在循环里面第一句话是那当前的某个数和后面的某个数交换（包括和自己交换，也就是不交换），交换完了之后，后面那个递归就是分治了，也就是从待交换的数的下一个开始直到末尾的一段调用递归用分治搞定。分治一直调用到最后无法交换的时候，也就是末尾两个指针相遇的时候程序就输出一种排列。所以在递归退出之后，根据程序的逻辑，在当前层循环里面应该只负责当前数和后面的数的交换，而当前数不能变，所以要把现场恢复，因此还需要调用一次 swap 再交换回来就可以了。所以根据程序逻辑，应该选择 C 。自己画一个三个数的排列就可以看明白了， 9 个数太复杂，搞明白关系就可以了。

void run(int n) {//处理[n,N-1]的元素排列
	int i;
	if(N - 1 == n) {
    	// 打印结果;
    	return;
	}
	for(i = n; i < N; i++) {
  		// i从n开始主要是要包含不交换这种情况
  		
    	swap(n, i);	// 从第n个元素依次和后面的元素进行交换.，i=n,表示不交换，原序打印
    	run(n + 1);	// 处理[n+1,N-1]的元素排列
    	swap(n, i);	// 交换回原样，以便再递归处理后面的元素
    }
}

---

如有不同见解，欢迎留言讨论