Palavra-chave auto em C++: dedução de tipos com exemplos

Deixe o compilador escolher o tipo

Na página anterior você viu que toda variável de C++ tem um tipo fixo - int, double, std::string e assim por diante. Escrever esse tipo à mão é tranquilo para int count = 0;, mas vira poluição visual quando os tipos ficam longos. A palavra-chave auto (C++11 e posteriores) deixa o compilador deduzir o tipo a partir do valor que você atribui, então você escreve o valor uma vez e deixa o compilador preencher o resto.

#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;
}

A ideia central: auto não é tipagem dinâmica. Cada variável continua tendo um único tipo concreto, travado em tempo de compilação. O auto apenas poupa você de escrevê-lo.

Por que o auto vale a pena

Para tipos curtos e óbvios, auto count = 0; e int count = 0; são igualmente legíveis. Onde o auto realmente compensa é com nomes de tipos longos e repetitivos - aqueles que surgem dos contêineres e iteradores da biblioteca padrão.

Compare a versão verbosa com a versão com auto:

// Sem auto - na prática, o tipo é escrito duas vezes
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// Com auto - o compilador já conhece o tipo
auto it = scores.begin();

Ambas declaram exatamente o mesmo tipo de iterador. A segunda é mais fácil de ler e não vai ficar dessincronizada se mais tarde você mudar scores para outro contêiner.

Aqui está em um programa completo:

#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 em laços for baseados em intervalo

O lugar mais comum onde você vai encontrar auto é o laço for baseado em intervalo. Você quase nunca quer escrever o tipo do elemento à mão, e como você escreve o auto decide se você recebe uma cópia ou uma referência.

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

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

    // const auto& - somente leitura, sem cópia. O padrão usual para ler.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Três variantes que você vai ver, e o que cada uma significa:

• for (auto x : v) - x é uma cópia de cada elemento. Barato para int, desperdício para objetos grandes.
• for (auto& x : v) - x é uma referência; você pode modificar os elementos no lugar.
• for (const auto& x : v) - x é uma referência somente leitura. Use quando você só precisa ler.

Este próximo programa modifica o contêiner através de auto&:

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

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

    for (auto& n : nums) {
        n *= 10;        // modifica o elemento real
    }

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

Pegadinha: escreva for (auto n : nums) (sem &) nesse laço e o n *= 10 mudaria silenciosamente apenas a cópia, deixando nums intocado. O compilador não vai avisar você - o laço simplesmente não faz nada útil.

O que o auto descarta

Um auto simples deduz o tipo da mesma forma que um parâmetro de função por valor: ele descarta o const de nível superior, referências e volatile. Isso significa que auto sempre te dá uma cópia nova e modificável, a menos que você peça o contrário.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // o tipo é int, NÃO const int
    copy = 100;             // perfeitamente legal - o const foi descartado

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

Se você quer manter o const ou evitar a cópia, você adiciona os qualificadores você mesmo. O padrão é decorar o auto da mesma forma que você decoraria qualquer tipo:

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

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

    const auto& ref = name;   // const std::string& - sem cópia, somente leitura
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // erro: ref é const
    return 0;
}

Então auto deduz o tipo base; &, const e * são botões que você adiciona por cima. auto é o tipo, const auto& é uma referência somente leitura para ele.

Erros comuns e pegadinhas

auto elimina o esforço de digitar, não a necessidade de entender os tipos. Algumas armadilhas pegam os iniciantes:

Você precisa inicializar. auto não tem nada para deduzir a partir de uma declaração vazia, então isso é um erro de compilação irremediável:

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // ok

Literais inteiros são int, não double. auto half = 1 / 2; deduz int e armazena 0, porque 1 / 2 é divisão inteira antes de o auto sequer ver isso. O tipo segue o valor:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // divisão inteira -> 0
    auto right = 1.0 / 2;    // double -> 0.5

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

auto descarta a referência - cuidado com surpresas de cópia pendente. Se uma função retorna uma referência e você a captura com auto simples, você recebe uma cópia, o que às vezes é um problema real de desempenho em um laço quente (uma cópia profunda de um objeto grande a cada iteração). Recorra a const auto& quando você quer dizer "olhar, não levar".

Não esconda o tipo quando ele importa. auto result = compute(); é tranquilo quando o tipo de retorno de compute é óbvio pelo contexto, mas se quem lê tem que caçar o que result realmente é, escrever o tipo pode ser a escolha mais amigável. auto serve para cortar poluição, não para esconder a intenção.

Próximo: Constantes e const

Você já viu que o auto deliberadamente descarta const a menos que você peça para mantê-lo - o que levanta a pergunta óbvia: o que o const realmente garante, e quando você deveria marcar um valor como imutável em primeiro lugar? A próxima página se aprofunda em const, expressões constantes e por que "torne-o const por padrão" é um dos hábitos mais úteis em C++.