auto n = 10;
auto f = 12.8;
auto p = &n;
auto url = "http://c.biancheng.net/cplus/";
第 1 行中，10 是一个整数，默认是 int 类型，所以推导出变量 n 的类型是 int
第 2 行中，12.8 是一个小数，默认是 double 类型，所以推导出变量 f 的类型是 double。
第 3 行中，&n 的结果是一个 int* 类型的指针，所以推导出变量 f 的类型是 int *。
第 4 行中，由双引号""包围起来的字符串是 const char* 类型，所以推导出变量 url 的类型是 const char*，也即一个常量指针
int n = 20;
auto *p = &n, m = 99;
先看前面的第一个子表达式，&n 的类型是 int*，编译器会根据 auto *p 推导出 auto 为 int。后面的 m 变量自然也为 int 类型，所以把 99 赋值给它也是正确的。
这里我们要注意，推导的时候不能有二义性。在本例中，编译器根据第一个子表达式已经推导出 auto 为 int 类型，那么后面的 m 也只能是 int 类型，如果写作m=12.5就是错误的，因为 12.5 是double 类型，这和 int 是冲突的。
还有一个值得注意的地方是：使用 auto 类型推导的变量必须马上初始化，这个很容易理解，因为 auto 在 C++11 中只是“占位符”，并非如 int 一样的真正的类型声明。
auto 的高级用法
auto 除了可以独立使用，还可以和某些具体类型混合使用，这样 auto 表示的就是“半个”类型，而不是完整的类型。
int x = 0;
auto *p1 = &x; //p1 为 int *，auto 推导为 int
auto p2 = &x; //p2 为 int*，auto 推导为 int*
auto &r1 = x; //r1 为 int&，auto 推导为 int
auto r2 = r1; //r2 为 int，auto 推导为 int
第 2 行代码中，p1 为 int* 类型，也即 auto * 为 int *，所以 auto 被推导成了 int 类型。
第 3 行代码中，auto 被推导为 int* 类型，前边的例子也已经演示过了。
第 4 行代码中，r1 为 int & 类型，auto 被推导为 int 类型。
第 5 行代码是需要重点说明的，r1 本来是 int& 类型，但是 auto 却被推导为 int 类型，这表明当=右边的表达式是一个引用类型时，auto 会把引用抛弃，直接推导出它的原始类型。
int x = 0;
const auto n = x; //n 为 const int ，auto 被推导为 int
auto f = n; //f 为 const int，auto 被推导为 int（const 属性被抛弃）
const auto &r1 = x; //r1 为 const int& 类型，auto 被推导为 int
auto &r2 = r1; //r1 为 const int& 类型，auto 被推导为 const int 类型
第 2 行代码中，n 为 const int，auto 被推导为 int。
第 3 行代码中，n 为 const int 类型，但是 auto 却被推导为 int 类型，这说明当=右边的表达式带有 const 属性时， auto 不会使用 const 属性，而是直接推导出 non-const 类型。
第 4 行代码中，auto 被推导为 int 类型，这个很容易理解，不再赘述。
第 5 行代码中，r1 是 const int & 类型，auto 也被推导为 const int 类型，这说明当 const 和引用结合时，auto 的推导将保留表达式的 const 类型。
auto 与 const 结合的用法：
1. 当类型不为引用时，auto 的推导结果将不保留表达式的 const 属性；
2. 当类型为引用时，auto 的推导结果将保留表达式的 const 属性。
auto 的限制
1. 使用 auto 的时候必须对变量进行初始化
2. auto 不能在函数的参数中使用。
我们在定义函数的时候只是对参数进行了声明，指明了参数的类型，但并没有给它赋值，只有在实际调用函数的时候才会给参数赋值；而 auto 要求必须对变量进行初始化，所以这是矛盾的。
3. auto 不能作用于类的非静态成员变量（也就是没有 static 关键字修饰的成员变量）中。
4. auto 关键字不能定义数组，比如下面的例子就是错误的：
char url[] = "http://c.biancheng.net/";
auto str[] = url; //arr 为数组，所以不能使用 auto
5. auto 不能作用于模板参数，
template <typename T>
class A{
//TODO:
};
int main(){
A<int> C1;
A<auto> C2 = C1; //错误
return 0;
}
auto 的应用
1. 使用 auto 定义迭代器
#include <vector>
using namespace std;
int main(){
vector< vector<int> > v;
vector< vector<int> >::iterator i = v.begin();
return 0;
}
#include <vector>
using namespace std;
int main(){
vector< vector<int> > v;
auto i = v.begin(); //使用 auto 代替具体的类型
return 0;
}
auto 用于泛型编程
#include <iostream>
using namespace std;
class A{
public:
static int get(void){
return 100;
}
};
class B{
public:
static const char* get(void){
return "http://c.biancheng.net/cplus/";
}
};
template <typename T>
void func(void){
auto val = T::get();
cout << val << endl;
}
int main(void){
func<A>();
func<B>();
return 0;
}
不使用 auto 的解决办法
#include <iostream>
using namespace std;
class A{
public:
static int get(void){
return 100;
}
};
class B{
public:
static const char* get(void){
return "http://c.biancheng.net/cplus/";
}
};
template <typename T1, typename T2> //额外增加一个模板参数 T2
void func(void){
T2 val = T1::get();
cout << val << endl;
}
int main(void){
//调用时也要手动给模板参数赋值
func<A, int>();
func<B, const char*>();
return 0;
}
网友评论