1. auto关键字
(1)auto的作用是让编译器自动推断变量的类型,而不需要显式指定类型。这种隐式类型的推导发生在编译期。
(2)auto并不能代表实际的类型声明,只是一个类型声明的“占位符”
(3)auto声明的变量必须马上初始化,以让编译器推断出它的实际类型。
【编程实验】auto的基本用法
//1.1.cpp
#include <iostream> #include <typeinfo> //编译:vc: cl 1.1.cpp // g++: g++ -std=c++11 1.1.cpp using namespace std; double foo(){return 0.0;}; struct m{ int i; }sm; int main() { auto x = 1; //x:int(其实1为const int类型,auto丢弃const) auto y = foo(); //y:double auto z = sm; //m1: struct m const auto* u = &x, v = 6; //u: const int*, v: int类型(注意不是const int) //auto的类型由u的类型决定,因此v不能初始化为6.0之类 static auto w = 0.0; //w:double; //auto s; //error: 无法推导。s必须被初始化 cout << "x: " << typeid(x).name() << endl; cout << "y: " << typeid(y).name() << endl; cout << "z: " << typeid(z).name() << endl; cout << "u: " << typeid(u).name() << endl; cout << "v: " << typeid(v).name() << endl; cout << "w: " << typeid(w).name() << endl; return 0; } /*输出结果: x: int y: double z: struct m u: int const * v: int w: double */
2. auto的推导规则
(1)当直接使用auto声明变量时(如auto varName),auto的推导结果和初始化表达式抛弃引用和cv限定符(const和volatile)后的类型一致。即auto将丢弃初始化表达式的cv属性。(原因 :auto varName说明varName是按值传递,它是原对象/变量的副本,所以可以在副本上进行修改操作,所以并不需要保留const等属性)
(2)当auto后面显式添加&时(如auto& varName)时,推导结果才会保留初始化表达式的cv属性和引用。(原因:由于引用代表对象本身,所以原对象/变量如果有cv属性,则应该被保留下来)
(3)当auto*或auto推导结果为指针,保留指针的底层cv操作符。除2、3两种情况外,均不保留cv和引用。
(4)同一赋值语句中,用auto来声明多个变量类型时,只有第一个变量用于auto的类型推导,然后推导出来的数据类型作用于其他变量。因此,这些变量的类型必须相同。否则,编译器则会报错。
(5)auto是从左向右推导,类似于字面替换的方式进行。
(6)new和初始化列表中也可以使用auto关键字
【实例分析】auto和auto&(auto*)的差异
//1.2.cpp
#include <iostream> #include <typeinfo> using namespace std; //编译:vc: cl 1.2.cpp // g++: g++ -std=c++11 1.2.cpp double foo(){return 0.0;}; int main() { auto x = 1; //x: int(注意1为const int类型,但auto会丢弃const限定符) int* y=&x; auto* a = &x; //a: int* auto: int auto b = &x; //b: int* auto: int* auto& c = x; //c: int&, auto: int //auto和auto&:当初始化表达式为引用时 auto d = c; //d: int, auto: int(注意:c为引用,但会被auto会丢弃,故d为int) auto& e = c; //e: int&, auto: int(auto&会保留引用和cv限制符) //auto和auto&: 当初始化表达式带cv限定符时 const auto f = x; //f: const int, auto: int auto g = f; //注意此处:g: int(因为auto会丢弃初始化表达式的cv限定符) auto& h = f; //注意此处:h:const int&(auto&会保留f的const属性) auto* i = &f; //注意此处:i:const int*(auto*会保留f的const属性) //auto从左向右推导 auto o = 1, &p = o, *q = &p; //o: int, p: int&, q: int* auto r = 1, s = 2; //auto根据r推导出auto为int,因此s为int //单行声明变量的陷阱(建议:多变量尽量分多行声明) const auto* m = &x, n = 1; //m: const int*,但n为int(注意不带const) //初始化列表中使用auto auto x1(1); //x1: int auto x2 {1}; //x2: int //new中使用auto auto x3 = new auto(1); cout << "a: " << typeid(a).name() << endl; cout << "b: " << typeid(b).name() << endl; cout << "c: " << typeid(c).name() << endl; cout << "d: " << typeid(d).name() << endl; cout << "e: " << typeid(e).name() << endl; cout << "f: " << typeid(f).name() << endl; cout << "g: " << typeid(g).name() << endl; cout << "h: " << typeid(h).name() << endl; cout << "i: " << typeid(i).name() << endl; cout << "o: " << typeid(o).name() << endl; cout << "p: " << typeid(p).name() << endl; cout << "q: " << typeid(q).name() << endl; cout << "r: " << typeid(r).name() << endl; cout << "m: " << typeid(m).name() << endl; cout << "n: " << typeid(n).name() << endl; cout << "x1: " << typeid(x1).name() << endl; cout << "x2: " << typeid(x2).name() << endl; cout << "x3: " << typeid(x3).name() << endl; return 0; } /*输出结果 a: int * b: int * c: int d: int e: int f: int g: int h: int i: int const * o: int p: int q: int * r: int m: int const * n: int x1: int x2: int x3: int * */
3. auto的限制
(1)auto不能用于函数参数。如果需要泛型参数,可借助于模板
(2)auto不能用于非静态成员变量
(3)auto无法定义数组
(4)auto无法推导模板参数
【实例分析】auto使用受限
//1.3.cpp
#include <iostream> #include <vector> #include <typeinfo> using namespace std; //编译:vc: cl 1.3.cpp // g++: g++ -std=c++11 1.3.cpp void func(auto a = 1){} //error: 不能用于函数参数。泛型参数可借助模板来实现 struct Foo { static const auto var2 = 0; //OK: 静态成员函数,可用auto推导 auto var1 = 0; //error:非静态成员函数,不能用auto推导 }; int main() { char x[3] ={0}; auto y = x; //OK: y: int*(注意:不是char[3]) auto z[3] = x; //error: auto无法定义数组 vector<auto> v = {1}; //error: auto不能用于模板参数 return 0; }
4. auto的优势
(1)auto最大优势简化代码,特别是当声明的变量类型比较复杂的时候。
(2)避免类型声明时的错误。C/C++存在很多隐式或用户自定义的类型转换规则,这些规则不容易记忆,这时auto就可以用于自动推导。
(3)auto的“自适应”能够在一定程序上支持泛型编程。如strlen函数返回值,在32位编译环境下,返回一个4字节的整型,64位返回一个8字节的整型。可以使用auto关键字达到代码跨平台的效果。
【实例分析】auto的优势
//1.4.cpp
#include <iostream> #include <map> //编译:vc: cl 1.4.cpp // g++: g++ -std=c++11 1.4.cpp //1. 简化迭代器变量的声明 void func() { std::map<double, double> resMap; //优化前 // std::map<double, double>::iterator = it = resMap.begin(); // for(; it != resMap.end(); ++it){ // //do something; // } //优化后 for(auto it = resMap.begin(); it != resMap.end(); ++it){ //do something } } //2. 避免类型声明错误 class PI { const float val = 3.1415927f; public: double operator* (float v){ return (double)val * v; //精度被扩展 } }; //3. auto对类型的自适应 template <typename T1, typename T2> double Sum(T1& t1, T2& t2) { auto s = t1 + t2; //s的类型会在模板实例化时被推导出来 } int main() { //demo: 避免auto类型声明 float radius = 1.7e10; PI pi; //operator*的返回值为double,但使用PI这个类的人可能不知道 //PI类的设计者为了避免数据上溢而返回了double类型。这时可以 //用auto来自动推导operator*的返回类型。同时假如PI的作者改动 //了PI的定义,将operator*的返回值改为了long double,此时main //函数并不需要修改,因为auto会“自适应”新的类型 auto circumference = 2 * (pi * radius); //demo: auto的自适应 int a = 3; long b = 5; float c = 1.0f, d = 2.3f; auto e = Sum<int, long>(a, b); //s==> long; auto f = Sum<float, float>(c, d); //s==>float; return 0; }
原文链接: https://www.cnblogs.com/5iedu/p/6893725.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍;
也有高质量的技术群,里面有嵌入式、搜广推等BAT大佬
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/393384
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!