Ключевое слово auto в C++: вывод типов на примерах

Пусть тип выбирает компилятор

На предыдущей странице вы видели, что у каждой переменной C++ есть фиксированный тип — int, double, std::string и так далее. Писать этот тип вручную нормально для int count = 0;, но это становится загромождающим, как только типы удлиняются. Ключевое слово auto (C++11 и более поздние) позволяет компилятору вывести тип из значения, которое вы присваиваете, так что вы пишете значение один раз и предоставляете компилятору заполнить остальное.

#include <iostream>
using namespace std;

int main() {
    auto count = 0;        // int
    auto price = 3.99;     // double
    auto letter = 'A';     // char
    auto greeting = "hi";  // const char*

    cout << count << " " << price << " " << letter << " " << greeting << "\n";
    return 0;
}

Ключевая мысль: auto это не динамическая типизация. У каждой переменной по-прежнему есть один конкретный тип, зафиксированный во время компиляции. auto просто избавляет вас от его написания.

Почему auto оправдывает себя

Для коротких, очевидных типов auto count = 0; и int count = 0; одинаково читаемы. По-настоящему auto окупается с длинными, повторяющимися именами типов — теми, что получаются из контейнеров и итераторов стандартной библиотеки.

Сравните многословную версию с версией на auto:

// Без auto - по сути, тип написан дважды
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// С auto - компилятор уже знает тип
auto it = scores.begin();

Обе объявляют ровно один и тот же тип итератора. Вторую легче читать, и она не рассинхронизируется, если позже вы смените scores на другой контейнер.

Вот это в полной программе:

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<pair<string, int>> scores = {{"Ada", 90}, {"Boris", 85}};

    for (auto it = scores.begin(); it != scores.end(); ++it) {
        cout << it->first << ": " << it->second << "\n";
    }
    return 0;
}

auto в циклах for на основе диапазона

Самое распространённое место, где вы встретите auto, это цикл for на основе диапазона. Вы почти никогда не захотите писать тип элемента вручную, и то, как вы пишете auto, решает, получите ли вы копию или ссылку.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<string> names = {"Ada", "Boris", "Rosa"};

    // const auto& - только для чтения, без копии. Обычный вариант по умолчанию для чтения.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Три варианта, которые вы увидите, и что означает каждый:

• for (auto x : v) - x это копия каждого элемента. Дёшево для int, расточительно для крупных объектов.
• for (auto& x : v) - x это ссылка; вы можете изменять элементы на месте.
• for (const auto& x : v) - x это ссылка только для чтения. Используйте её, когда вам нужно только читать.

Следующая программа изменяет контейнер через auto&:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {
        n *= 10;        // изменяет настоящий элемент
    }

    for (const auto& n : nums) {
        cout << n << " ";   // 10 20 30
    }
    cout << "\n";
    return 0;
}

Ловушка: напишите for (auto n : nums) (без &) в этом цикле, и n *= 10 молча изменит только копию, оставив nums нетронутым. Компилятор не предупредит вас — цикл просто не делает ничего полезного.

Что отбрасывает auto

Простой auto выводит тип так же, как параметр функции, передаваемый по значению: он отбрасывает const верхнего уровня, ссылки и volatile. Это означает, что auto всегда даёт вам свежую, изменяемую копию, если вы не попросите об ином.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // тип int, а НЕ const int
    copy = 100;             // совершенно законно - const был отброшен

    cout << original << " " << copy << "\n";  // 42 100
    return 0;
}

Если вы хотите сохранить const или избежать копии, вы добавляете квалификаторы сами. Приём в том, чтобы украшать auto так же, как вы украшали бы любой тип:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name = "Ada";

    const auto& ref = name;   // const std::string& - без копии, только для чтения
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // ошибка: ref является const
    return 0;
}

Итак, auto выводит базовый тип; &, const и * это ручки, которые вы добавляете сверху. auto это тип, а const auto& это ссылка на него только для чтения.

Распространённые ошибки и ловушки

auto устраняет усилия по набору, а не необходимость понимать типы. Несколько ловушек подстерегают новичков:

Вы обязаны инициализировать. auto нечего выводить из пустого объявления, поэтому это однозначная ошибка компиляции:

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // нормально

Целочисленные литералы это int, а не double. auto half = 1 / 2; выводит int и хранит 0, потому что 1 / 2 это целочисленное деление до того, как auto его вообще увидит. Тип следует за значением:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // целочисленное деление -> 0
    auto right = 1.0 / 2;    // double -> 0.5

    cout << wrong << " " << right << "\n";  // 0 0.5
    return 0;
}

auto отбрасывает ссылку — остерегайтесь сюрпризов с висячими копиями. Если функция возвращает ссылку, а вы захватываете её простым auto, вы получаете копию, что иногда является настоящей ошибкой производительности в горячем цикле (глубокая копия большого объекта на каждой итерации). Прибегайте к const auto&, когда имеете в виду «смотреть, но не брать».

Не скрывайте тип, когда он важен. auto result = compute(); нормально, когда тип возвращаемого значения compute очевиден из контекста, но если читателю приходится выискивать, чем на самом деле является result, выписать тип может быть более дружелюбным выбором. auto нужен для уменьшения шума, а не для сокрытия намерения.

Далее: Константы и const

Теперь вы видели, что auto намеренно отбрасывает const, если вы не попросите его сохранить, — что поднимает очевидный вопрос: что на самом деле гарантирует const и когда вообще стоит помечать значение как неизменяемое? Следующая страница углубляется в const, константные выражения и в то, почему «делай его const по умолчанию» это одна из самых полезных привычек в C++.