首页 > 编程笔记 > C++笔记 阅读:1,145

C++ auto(类型推导)精讲

C++11 引入了 auto 和 decltype 关键字实现类型推导,通过这两个关键字不仅能方便地获取复杂的类型,而且还能简化书写,提高编码效率。本节我们先讲解 auto 关键字,下节再讲解 decltype 关键字。

auto 关键字的新意义

用过 C# 的读者可能知道,从 Visual C#3.0 开始,在方法范围中声明的变量可以具有隐式类型 var。例如,下面这样的写法(C#代码):

var i = 10;  // 隐式(implicitly)类型定义
int i = 10;  // 显式(explicitly)类型定义

其中,隐式的类型定义也是强类型定义,前一行的隐式类型定义写法和后一行的显式写法是等价的。

不同于 Python 等动态类型语言的运行时变量类型推导,隐式类型定义的类型推导发生在编译期。它的作用是让编译器自动推断出这个变量的类型,而不需要显式指定类型。

现在,C++11中 也拥有了类似的功能:auto 类型推导。其写法与上述 C# 代码等价:

auto i = 10;

是不是和 C# 的隐式类型定义很像呢?

下面看下 auto 的一些基本用法:
auto x = 5;                 // OK: x是int类型
auto pi = new auto(1);      // OK: pi被推导为int*
const auto *v = &x, u = 6;  // OK: v是const int*类型,u是const int类型
static auto y = 0.0;        // OK: y是double类型
auto int r;                 // error: auto不再表示存储类型指示符
auto s;                     // error: auto无法推导出s的类型
在上面的代码示例中:
  • 字面量 5 是一个 const int 类型,变量 x 将被推导为 int 类型(const被丢弃,后面说明),并被初始化为 5。
  • pi 的推导说明 auto 还可以用于 new 操作符。在例子中,new 操作符后面的 auto(1) 被推导为 int(1),因此 pi 的类型是 int*。
  • 接着,由 &x 的类型为 int*,推导出 const auto* 中的 auto 应该是 int,于是 v 被推导为 const int*,而 u 则被推导为 const int。
  • 最后 y、r、s 的推导过程比较简单,就不展开讲解了。读者可自行在支持 C++11 的编译器上实验。

v 和 u 的推导需要注意两点:
  • 虽然经过前面 const auto*v=&x 的推导,auto 的类型可以确定为 int 了,但是 u 仍然必须要写后面的=6,否则编译器不予通过。
  • u 的初始化不能使编译器推导产生二义性。例如,把 u 的初始化改成u=6.0,编译器将会报错:

    const auto *v = &x, u = 6.0;
    error: inconsistent deduction for 'const auto': 'int' and then 'double'


由上面的例子可以看出来,auto 并不能代表一个实际的类型声明(如 s 的编译错误),只是一个类型声明的“占位符”。使用 auto 声明的变量必须马上初始化,以让编译器推断出它的实际类型,并在编译时将 auto 占位符替换为真正的类型。

细心的读者可能会发现,auto 关键字其实并不是一个全新的关键字。在旧标准中,它代表“具有自动存储期的局部变量”,不过其实它在这方面的作用不大,比如:

auto int i = 0;  // C++98/03,可以默认写成 int i = 0;
static int j = 0;

上述代码中的 auto int 是旧标准中 auto 的使用方法。与之相对的是下面的 static int,它代表了静态类型的定义方法。

实际上,我们很少有机会这样直接使用 auto,因为非 static 的局部变量默认就是“具有自动存储期的”。

考虑到 auto 在 C++ 中使用的较少,在 C++11 标准中,auto 关键字不再表示存储类型指示符(storage-class-specifiers,例如 static、register、mutable 等),而是改成了一个类型指示符(type-specifier),用来提示编译器对此类型的变量做类型的自动推导。

auto 的推导规则

从上面的示例中可以看到 auto 的一些使用方法。它可以同指针、引用结合起来使用,还可以带上 cv 限定符(cv-qualifier,const 和 volatile 限定符的统称)。

再来看一组例子:
int x = 0;
auto * a = &x;      // a -> int*,auto被推导为int
auto   b = &x;      // b -> int*,auto被推导为int*
auto & c = x;       // c -> int&,auto被推导为int
auto   d = c;       // d -> int ,auto被推导为int
const auto e = x;   // e -> const int
auto f = e;         // f -> int
const auto& g = x;  // e -> const int&
auto& h = g;        // f -> const int&
由上面的例子可以看出:
  • a 和 c 的推导结果是很显然的,auto 在编译时被替换为 int,因此 a 和 c 分别被推导为 int* 和 int&。
  • b 的推导结果说明,其实 auto 不声明为指针,也可以推导出指针类型。
  • d 的推导结果说明当表达式是一个引用类型时,auto 会把引用类型抛弃,直接推导成原始类型 int。
  • e 的推导结果说明,const auto 会在编译时被替换为 const int。
  • f 的推导结果说明,当表达式带有 const(实际上 volatile 也会得到同样的结果)属性时,auto 会把 const 属性抛弃掉,推导成 non-const 类型 int。
  • g、h 的推导说明,当 auto 和引用(换成指针在这里也将得到同样的结果)结合时,auto 的推导将保留表达式的 const 属性。

通过上面的一系列示例,可以得到下面这两条规则:
  • 当不声明为指针或引用时,auto 的推导结果和初始化表达式抛弃引用和 cv 限定符后类型一致。
  • 当声明为指针或引用时,auto 的推导结果将保持初始化表达式的 cv 属性。

看到这里,对函数模板自动推导规则比较熟悉的读者可能会发现,auto 的推导和函数模板参数的自动推导有相似之处。比如上面例子中的 auto,和下面的模板参数自动推导出来的类型是一致的:
template <typename T> void func(T   x) {}        // T   -> auto
template <typename T> void func(T * x) {}        // T * -> auto *
template <typename T> void func(T & x) {}        // T & -> auto &
template <typename T> void func(const T   x) {}  // const T   -> const auto
template <typename T> void func(const T * x) {}  // const T * -> const auto *
template <typename T> void func(const T & x) {}  // const T & -> const auto &

注意:auto 是不能用于函数参数的。上面的示例代码只是单纯比较函数模板参数推导和 auto 推导规则的相似处。

因此,在熟悉 auto 推导规则时,可以借助函数模板的参数自动推导规则来帮助和加强理解。

auto 的限制

上面提到了 auto 是不能用于函数参数的。那么除了这个之外,还有哪些限制呢?

我们通过下面的代码来演示一下 auto 的限制:
void func(auto a = 1) {}          // error: auto不能用于函数参数
struct Foo
{
    auto var1_ = 0;               // error: auto不能用于非静态成员变量
    static const auto var2_ = 0;  // OK: var2_ -> static const int
};
template <typename T>
struct Bar {};

int main(void)
{
    int arr[10] = {0};
    auto aa     = arr;   // OK: aa -> int *
    auto rr[10] = arr;   // error: auto无法定义数组
    Bar<int> bar;
    Bar<auto> bb = bar;  // error: auto无法推导出模板参数
    return 0;
}
在 Foo 中,auto 仅能用于推导 static const 的整型或者枚举成员(因为其他静态类型在 C++ 标准中无法就地初始化),虽然 C++11 中可以接受非静态成员变量的就地初始化,但却不支持 auto 类型非静态成员变量的初始化。

在 main 函数中,auto 定义的数组 rr 和 Bar<auto>bb 都是无法通过编译的。

注意 main 函数中的 aa 不会被推导为 int[10],而是被推导为 int*。这个结果可以通过 auto 与函数模板参数自动推导的对比来理解。

什么时候用 auto

前面说了这么多,最重要的是,应该在什么时候使用 auto 呢?

在 C++11 之前,定义了一个 stl 容器以后,在遍历的时候常常会写这样的代码:
#include <map>
int main(void)
{
    std::map<double, double> resultMap;
    // ...
    std::map<double,double>::iterator it = resultMap.begin();
    for(; it != resultMap.end(); ++it)
    {
        // do something
    }
    return 0;
}
观察上面的迭代器(iterator)变量it的定义过程,总感觉有点憋屈。其实通过 resultMap.begin(),已经能够知道 it 的具体类型了,却非要书写上长长的类型定义才能通过编译。

来看看使用了 auto 以后的写法:
#include <map>
int main(void)
{
    std::map<double, double> resultMap;
    // ...
    for(auto it = resultMap.begin(); it != resultMap.end(); ++it)
    {
        // do something
    }
    return 0;
}
再次观察 it 的定义过程,是不是感到清爽了很多?

再看一个例子,在一个 unordered_multimap 中查找一个范围,代码如下:
#include <map>
int main(void)
{
    std::unordered_multimap<int, int> resultMap;
    // ...
    std::pair< std::unordered_multimap<int,int>::iterator, std::unordered_multimap<int, int>::iterator > range = resultMap.equal_range(key);
    return 0;
}
这个 equal_range 返回的类型声明显得烦琐而冗长,而且实际上并不关心这里的具体类型(大概知道是一个 std::pair 就够了)。这时,通过 auto 就能极大的简化书写,省去推导具体类型的过程:
#include <map>
int main(void)
{
    std::unordered_multimap<int, int> map;
    // ...
    auto range = map.equal_range(key);
    return 0;
}
另外,在很多情况下我们是无法知道变量应该被定义成什么类型的,比如下面的例子。

【实例】auto 简化函数定义的示例。
class Foo
{
    public:
    static int get(void)
    {
        return 0;
    }
};
class Bar
{
    public:
    static const char* get(void)
    {
        return "0";
    }
};
template <class A>
void func(void)
{
    auto val = A::get();
    // ...
}
int main(void)
{
    func<Foo>();
    func<Bar>();
    return 0;
}
在这个例子里,我们希望定义一个泛型函数 func,对所有具有静态 get 方法的类型 A,在得到 get 的结果后做统一的后续处理。若不使用 auto,就不得不对 func 再增加一个模板参数,并在外部调用时手动指定 get 的返回值类型。

上面给出的各种示例仅仅只是实际应用中很少的一部分,但也足以说明 auto 关键字的各种常规使用方法。更多的适用场景,希望读者能够在实际的编程中亲身体验。

注意 auto 是一个很强大的工具,但任何工具都有它的两面性。不加选择地随意使用 auto,会带来代码可读性和维护性的严重下降。因此,在使用 auto 的时候,一定要权衡好它带来的“价值”和相应的“损失”。

爱面试的程序媛,一个分享面试经验的公众号。跟着站长一起学习,每天都有进步。

通俗易懂,深入浅出,定时分享程序员面试的那点事。

面试如何造火箭?工作如何拧螺丝?都在这个公号哦。

扫描二维码关注公众号,免费领取价值 1000 元的求职面试资料(限时免费)!

当你决定关注「爱面试的程序媛」,你已然超越了90%的程序员!

爱面试的程序媛二维码
微信扫描二维码关注