C++ auto关键字

C++ auto

语法

• auto declarator initializer* ;
• [ ](auto param1 , auto param2) {};

使用 auto 隐式确定变量类型：

// 使用auto隐式确定变量类型
int j = 0;  // 变量 j 显式确定为int
auto k = 0; // 变量 k 隐式确定为int

使用auto作为 for 和 range_for 循环的初始条件：

map<int,string> m;
// 使用auto表示迭代器变量类型，以下两种等效
map<int,string>::iterator i = m.begin();
auto i = m.begin();

deque<int> dq(10, 1);
// 使用auto声明for和range_for循环的开始条件
for (auto iter = dq.begin(); iter != dq.end(); ++iter)
{ /* ... */ }

for (auto elem : dq) // 复制一份dq中的元素赋值给elem，效率与方法1接近
{ /* ... */ }

for (auto& elem : dq) // elem引用dq中的每个元素，对dq进行原地读取和修改
{ /* ... */ }

for (const auto& elem : dq) // elem常量引用dq中的每个元素，对dq进行原地读取
{ /* ... */ }

如果在一个声明语句中使用 auto 声明多个符号，每个语句中的所有符号都会解析为相同类型：

// 使用new运算符和指针来声明指针
double x = 12.34;
auto *y = new auto(x), **z = new auto(&x);

// 如果在一个声明语句中使用auto声明多个符号，每个语句中的所有符号都会解析为相同类型
auto x = 1, *y = &x, **z = &y; // xyz 的类型都为int
auto a(2.01), *b(&a);         // ab 的类型都为double
auto c = 'a', *d(&c);          // cd 的类型都为char
auto m = 1, &n = m;            // mn 的类型都为int

使用 auto 声明条件运算符的返回值：

//使用auto声明条件运算符的返回值
int v1 = 100, v2 = 200;
auto x = v1 > v2 ? v1 : v2;

使用 auto 将变量初始化为指向有返回值函数的指针：

#include <iostream>
using namespace std;

int func(int x)
{
    return x;
}

int main ()
{
    // 变量x初始化为int
    auto x = func(0);
    // 变量y初始化为const int类型的引用
    const auto& y = func(1);
    int (*p)(int x);
    p = func;
    // 将变量fp初始化为指向返回int类型的函数的指针
    auto fp = p;

    return 0;
}

auto 关键字的优点

大多数情况下建议使用auto关键字

• 鲁棒性：即使表达式的类型发生更改也能正常工作，如函数的返回值类型发生改变时。

• 性能：保证不会发生转换。

• 可用性：auto关键字是声明复杂类型变量的简单方法，可以避免类型名称拼写困难或拼写错误。

• 效率：写代码更高效。

不适用auto关键字的情况

• 明确需要某个数据类型，且没有其他变化时

• 表达式模板帮助器类型

使用说明符和声明符来修改 auto 关键字

如 const、volatile、pointer(*)、reference(&) 和 rvalue reference(&&)。编译器会计算初始化表达式，然后根据该信息推断变量类型。

使用 auto 初始化表达式的多种形式

• 通用初始化语法： auto a{42}；

• 赋值语法： auto b=0；

• 通用赋值语法： auto c={3.14156}；

使用 auto 声明循环语句中的循环参数

循环为基于范围的循环类型，如for和while，switch除外。

auto声明循环语句中的循环参数时，使用与赋值不同的初始化语法。例如 (auto&i:iterable)do_action(i)；

使用 auto 编写模板库

使用auto和decltype声明一个模板函数，其返回类型取决于其模板参数的类型。该模板函数可以调用另一个函数，并返回另一个函数的返回类型。

使用 auto 声明并初始化一个变量为 lambda 表达式

使用auto将变量声明和初始化为lambda表达式。

注意：lambda表达式的类型只有编译器知道，程序员不能自己声明变量类型

使用 auto 获取引用的数据类型和cv限定符

将引用赋值给 auto 数据类型的变量

• auto 为原数据类型，不保留变量间的引用关系。

将 const 数据类型赋值给 auto 数据类型的变量

• auto 获取数据类型时不保留const

#include <iostream>
using namespace std;

void func1()
{
    int count = 10;
    int& countRef = count;
    const int constcount = 10;
    auto myAuto = countRef;
    auto myAuto2 = constcount;

    countRef = 20;
    cout << "count: "<< count<<endl;
    cout << "countRef: "<< countRef<<endl;
    cout << "myAuto: "<< myAuto<<endl;
    cout << endl;

    myAuto = 16.9;
    cout << "count: "<< count<<endl;
    cout << "countRef: "<< countRef<<endl;
    cout << "myAuto: "<< myAuto<<endl;
    cout << endl;

    myAuto2 = 30;
    cout << "count: "<< count<<endl;
    cout << "countRef: "<< countRef<<endl;
    cout << "myAuto: "<< myAuto<<endl;
    cout << "constcount: "<< constcount<<endl;
    cout << "myAuto2: "<< myAuto2<<endl;
}

int main ()
{
    func1();

    return 0;
}

使用 auto 带括号的初始化语句内容的数据类型

列表初始化器： auto name= {item1,item2};，多个内容的数据类型应相同

直接列表初始化器：auto name{item};，内容应当只有一项

#include <iostream>
using namespace std;

void func1()
{
    // std::initializer_list<int>
    auto A = {1, 2};

    // std::initializer_list<int>
    auto B = {3};

    // int
    auto C{4};

    // 从列表初始化器中推断内容类型，内容的数据类型应当是相同的
    // auto D = {5,6.7};

    // 使用auto推断直接列表初始化器中内容的类型 anto name{item}，列表内容应当只有一项
    // auto E{8,9};
}

int main ()
{
    func1();
    return 0;
}

参考文章

auto (C++)：https://docs.microsoft.com/en-us/cpp/cpp/auto-cpp?view=msvc-170