大发体育娱乐在线-大发体育娱乐官方网站-大发体育娱乐登录网址
做最好的网站

auto类型说明符

来源:http://www.dfwstonefabricators.com 作者:大发体育网络 人气:108 发布时间:2019-11-15
摘要:[C++] auto类型说明符 我们经常会将表达式的值赋给变量,这就要求在变量声明时清楚地知道表达式的类型。有时候是很复杂的一件事,在C++11中引入了auto类型说明符,用它就能让编译器

[C++] auto类型说明符

我们经常会将表达式的值赋给变量,这就要求在变量声明时清楚地知道表达式的类型。有时候是很复杂的一件事,在C++11中引入了auto类型说明符,用它就能让编译器替我们去分析表达式所属的类型。当然,auto变量必须有初始值,这样编译器才能推断其类型:

 

 double val1 = 1.1, val2 = 2.2;
 auto item = val1 + val2;   // item为double类型

使用auto也能在一条语句中声明多个变量。因为一条语句只能有一个基本数据类型,因此该语句中所有变量的初始基本类型必须一致:

 

 

 auto i0 = 0, *pI = &i0;    // ok, i0为int类型, p为int指针
 auto sz = 0, pi = 3.14;    // fail, sz和pi类型不一致

 

编程时常常需要把表达式的值赋给变量,这就要求在声明变量的时候清楚知道表达式的类型。然而要做到这一点并非那么容易,有时候甚至根本做不到。为了解决这个问题,C++11标准引入了auto类型说明符,用它就能让编译器替我们去分析表达式所属的类型。

复合类型、const和auto

 

编译器推断出来的auto类型有时候和初始值类型不完全一致,编译器会适当的改变结果类型使其更符合初始化规则。

引用:使用引用实际上使用的是引用的对象,当引用被用作初始化时,真正参与初始化的其实是引用对象的值。此时,编译器以引用对象的类型作为auto的类型:

 

 int i = 0, &r = i;
 auto a = r;       // a是一个int,r是i的别名,而i是一个int

auto一般会忽略掉顶层const,而会保留底层const,比如当初始值是一个指向常量的指针时:

 

 

 const int ci = i, &cr = ci;
 auto b = ci;      // b是一个int,ci的顶层const被忽略
 auto c = cr;      // c是一个int,cr的顶层const被忽略
 auto d = &i;      // d是一个int型指针
 auto e = &ci;      // e是一个指向整型常量的指针,对常量对象取地址是一种底层const

若希望推断出的auto类型是一个顶层const,需要明确支出:

 

 

 const auto f = ci;

还可以将引用类型设置为auto,原来的初始化规则仍然适用,初始值的顶层const属性会被保留:

 

 

 auto &g = ci;      // g是一个整型常量引用,绑定到ci
 auto &h = 42;      // error, 不能为非常量引用绑定字面值
 const auto &j = 42;     // ok,可以为常量引用绑定字面值

要在一条语句中定义多个变量,符号&和*只从属于某个声明符,而非基本数据类型的一部分,因此初始值必须是同一类型:

 

 

 auto k = ci, &l = i;    // k是int, l是int&
 auto &m = ci, *p = &ci;    // m是对整型常量的引用,p是指向整型常量的指针
 auto &n = i, *p2 = &ci;    // error, n是对整型的引用,p2是指向整型常量的指针

一些额外的例子:

 

 

 const int i = 42;
 auto j = i;       // j是int
 const auto &k = i;     // k是int i的常量引用
 auto *p = &i;      // p是指向整型常量i的指针
 const auto j2 = i, &k2 = i;   // j2是整型常量, k2是int i的常量引用

 

] auto类型说明符 我们经常会将表达式的值赋给变量,这就要求在变量声明时清楚地知道表达式的类型。有时候是很复杂的一件事,在C...

与原来那些只对应一种特定类型的说明符不同,auto让编译器通过初值来推算变量类型。显然,auto定义的变量必须要有初始值。

使用auto具有以下几点好处:

可靠性:如果表达式的类型发生更改(包括函数返回值发生更改的情况),它也能工作。
性能:确保将不会进行转换。
可用性:不必担心类型名称拼写困难和拼写有误。
效率:代码会变得更高效。

auto item = val1 + val2; // 由val1和val2相加的结果推断出item的类型
auto i=0, *p = &i; // i是整数,p是整型指针

使用auto能在一条语句中声明多个变量。但是一条声明语句只能有一个基本数据类型,所以该语句中所有变量的初始基本数据类型都必须一致:

auto sz = 0, pi = 3.14; // Error!

编译器推断出的auto类型有时候和初始值的类型并不完全一样,编译器会适当地改变结果类型使其更符合初始化规则,例如:

使用auto会删除引用

int count = 10;
int& countRef = count;
auto myAuto = countRef;

countRef = 11;
cout << count << " "; // print 11

myAuto = 12;
cout << count << endl; // print 11

你可能会认为 myAuto 是一个 int 引用,但它不是。它只是一个 int,因为输出为 11 11,而不是 11 12;如果 auto 尚未删除此引用,则会出现此情况。

const限定符
先引入一种表述:顶层const表示指针本身是个常量,底层const表示指针所指的对象是一个常量。一般auto会忽略掉顶层const,同时底层const则会保留下来,例如:

int i = 0;
const int ci = i, &cr = ci;
auto b = ci; // b 是一个整数(ci的顶层const特性被忽略掉)
auto c = cr; // c 是一个整数(cr是ci的别名,ci本身是一个顶层const)
auto d = &i; // d 是一个整型指针(整数的地址就是指向整数的指针)
auto e = &ci; // e 是一个指向整数常量的指针(对常量对象取地址是一种底层const)

如果希望推断出的auto类型是一个顶层const,需要明确指出:

const auto f = ci; // ci 的推演类型是int,f是const int类型

还可以将引用的类型设置为auto,此时原来的初始化规则仍然适用:

auto &g = ci; // g是一个整型常量引用,绑定到ci
auto &h = 42; // Error: 不能为非常量引用绑定字面值
const auto &j = 42; // OK: 可以为常量引用绑定字面值

切记,符号*和&只从属于某个声明,而非基本数据类型的一部分,因此初始值必须是同一类型:

auto k = ci, &l = i; // k是整数,l是整型引用
auto &m = ci, *p = &ci; // m是对整型常量的引用,p是指向整型常量的指针
auto &n = i, *p2 = &ci; // Error: i的类型是int,而&ci的类型是const int

附上更多示例代码:

下面的声明等效。在第一个语句中,将变量j 声明为类型 int。在第二个语句中,将变量 k 推导为类型 int,因为初始化表达式 (0) 是整数

int j = 0; // Variable j is explicitly type int.
auto k = 0; // Variable k is implicitly type int because 0 is an integer.

以下声明等效,但第二个声明比第一个更简单。使用 auto 关键字的最令人信服的一个原因是简单

map<int,list<string>>::iterator i = m.begin(); 
auto i = m.begin(); 

使用 iter 和 elem 启动循环时

#include <deque>
using namespace std;

int main()
{
  deque<double> dqDoubleData(10, 0.1);

  for (auto iter = dqDoubleData.begin(); iter != dqDoubleData.end(); ++iter)
  { /* ... */ }

  // prefer range-for loops with the following information in mind
  // (this applies to any range-for with auto, not just deque)

  for (auto elem : dqDoubleData) // COPIES elements, not much better than the previous examples
  { /* ... */ }

  for (auto& elem : dqDoubleData) // observes and/or modifies elements IN-PLACE
  { /* ... */ }

  for (const auto& elem : dqDoubleData) // observes elements IN-PLACE
  { /* ... */ }
}

下面的代码片段使用 new 运算符和指针声明来声明指针

double x = 12.34;
auto *y = new auto(x), **z = new auto(&x);

下一个代码片段在每个声明语句中声明多个符号。请注意,每个语句中的所有符号将解析为同一类型。

auto x = 1, *y = &x, **z = &y; // Resolves to int.
auto a(2.01), *b (&a);     // Resolves to double.
auto c = 'a', *d(&c);     // Resolves to char.
auto m = 1, &n = m;      // Resolves to int.

此代码片段使用条件运算符 (?:) 将变量 x 声明为值为 200 的整数:

int v1 = 100, v2 = 200;
auto x = v1 > v2 ? v1 : v2;

下面的代码片段将变量 x 初始化为类型 int,将变量 y初始化对类型 const int 的引用,将变量 fp 初始化为指向返回类型 int 的函数的指针。

int f(int x) { return x; }
int main()
{
  auto x = f(0);
  const auto & y = f(1);
  int (*p)(int x);
  p = f;
  auto fp = p;
  //...
}

您可能感兴趣的文章:

  • C++利用stringstream进行数据类型转换实例
  • C++ decltype类型说明符

本文由大发体育娱乐在线发布于大发体育网络,转载请注明出处:auto类型说明符

关键词:

上一篇:随机数生成器

下一篇:没有了

频道精选

最火资讯