使用auto关键字的对象类型自动推导

1

double d{ 5.0 };

1
2
3
4
5
6
7
8

int main()
{
    auto d{ 5.0 }; // 5.0 是 double 字面值, 所以 d 是 double 类型
    auto i{ 1 + 2 }; // 1 + 2 结果是 int, 所以 i 是 int 类型
    auto x { i }; // i 是 int, 所以 x 也是 int 类型

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int add(int x, int y)
{
    return x + y;
}

int main()
{
    auto sum { add(5, 6) }; // add() 返回 int, 所以 sum 是 int 类型

    return 0;
}

1
2
3
4
5
6
7

int main()
{
    auto a { 1.23f }; // f 后缀导致 a 被推导为 float
    auto b { 5u };    // u 后缀导致 b 被推导为 unsigned int

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <iostream>

void foo()
{
}

int main()
{
    auto x;          // 编译器无法推导 x 的类型
    auto y{ };       // 编译器无法推导 y 的类型
    auto z{ foo() }; // z 不能是void类型, 所以本语句无效
    
    return 0;
}

1
2
3
4
5
6
7

int main()
{
    const int x { 5 }; // x 的类型是 const int
    auto y { x };      // y 的类型时 int (const 限定符被丢掉)

    return 0;
}

1
2
3
4
5
6
7
8
9

int main()
{
    const int x { 5 };  // x 的类型是 const int (编译器常量)
    auto y { x };       // y 的类型是 int (const 限定符被丢掉)

    constexpr auto z { x }; // z 的类型是 constexpr int (constexpr 是需要手动指定的)

    return 0;
}

1

auto s { "Hello, world" }; // s 的类型是 const char*, 而不是 std::string

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <string>
#include <string_view>

int main()
{
    using namespace std::literals; // 方便我们使用 s 和 sv 后缀

    auto s1 { "goo"s };  // "goo"s 是 std::string 字面值, 所以 s1 的类型被推导为 std::string
    auto s2 { "moo"sv }; // "moo"sv 是 std::string_view 字面值, 所以 s2 的类型被推导为 std::string_view

    return 0;
}

1
2
3
4
5
6
7

// 不容易阅读
int a { 5 };
double b { 6.7 };

// 对齐，容易阅读
auto c { 5 };
auto d { 6.7 };

1
2

int x; // oops, 忘记了初始化 x, 但编译器不会告警
auto y; // 编译器会报错，因为无法推导出变量y的类型

1
2
3
4

std::string_view getString();   // 返回 std::string_view 的一个函数

std::string s1 { getString() }; // bad: 从 std::string_view 转换为 std::string 可能很昂贵 (假设这不是您期望的行为)
auto s2 { getString() };        // good: 无需转换

1

auto y { 5 }; // oops, 我们想要一个double变量，但无意中提供了一个int的字面值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <iostream>

int main()
{
     auto x { 3 };
     auto y { 2 };

     std::cout << x / y << '\n'; // oops, 我们这里想要浮点数除法

     return 0;
}

1

auto sum { add(5, 6) + gravity };