Palabra clave auto en C++: deducción de tipos con ejemplos

Deja que el compilador elija el tipo

En la página anterior viste que toda variable de C++ tiene un tipo fijo: int, double, std::string, etc. Escribir ese tipo a mano está bien para int count = 0;, pero se vuelve ruidoso cuando los tipos crecen. La palabra clave auto (C++11 y posteriores) permite que el compilador deduzca el tipo a partir del valor que asignas, así escribes el valor una vez y dejas que el compilador rellene el 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;
}

La idea clave: auto no es tipado dinámico. Cada variable sigue teniendo un único tipo concreto, fijado en tiempo de compilación. auto solo te ahorra escribirlo.

Por qué auto vale la pena

Para tipos cortos y evidentes, auto count = 0; e int count = 0; se leen igual de bien. Donde auto realmente compensa es con nombres de tipos largos y repetitivos, los que aparecen con los contenedores e iteradores de la biblioteca estándar.

Compara la versión larga con la versión con auto:

// Sin auto: en la práctica el tipo se escribe dos veces
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// Con auto: el compilador ya conoce el tipo
auto it = scores.begin();

Ambas declaran exactamente el mismo tipo de iterador. La segunda es más fácil de leer y no quedará desincronizada si más adelante cambias scores por otro contenedor.

Aquí está dentro de un 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 en bucles for basados en rango

El lugar más habitual donde te encontrarás con auto es el bucle for basado en rango. Casi nunca querrás escribir a mano el tipo del elemento, y la forma en que escribas el auto decide si obtienes una copia o una referencia.

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

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

    // const auto& - solo lectura, sin copia. El valor predeterminado habitual para leer.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Tres variantes que verás, y lo que significa cada una:

• for (auto x : v) - x es una copia de cada elemento. Barato para int, derrochador para objetos grandes.
• for (auto& x : v) - x es una referencia; puedes modificar los elementos en el sitio.
• for (const auto& x : v) - x es una referencia de solo lectura. Úsala cuando solo necesites leer.

Este siguiente programa modifica el contenedor a travé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 el elemento real
    }

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

Trampa: si escribes for (auto n : nums) (sin &) en ese bucle, n *= 10 cambiaría silenciosamente solo la copia, dejando nums intacto. El compilador no te avisará: el bucle simplemente no hace nada útil.

Qué descarta auto

Un auto simple deduce el tipo igual que lo hace un parámetro de función por valor: descarta el const de nivel superior, las referencias y volatile. Eso significa que auto siempre te da una copia nueva y modificable, salvo que pidas otra cosa.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // el tipo es int, NO const int
    copy = 100;             // perfectamente legal - el const se descartó

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

Si quieres conservar el const o evitar la copia, añades los calificadores tú mismo. El patrón es decorar auto igual que decorarías cualquier tipo:

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

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

    const auto& ref = name;   // const std::string& - sin copia, solo lectura
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // error: ref es const
    return 0;
}

Así que auto deduce el tipo base; &, const y * son perillas que añades encima. auto es el tipo, const auto& es una referencia de solo lectura a él.

Errores comunes y trampas

auto elimina el esfuerzo de escribir, no la necesidad de entender los tipos. Hay algunas trampas que pillan a los principiantes:

Tienes que inicializar. auto no tiene nada de lo que deducir en una declaración vacía, así que esto es un error de compilación irremediable:

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

Los literales enteros son int, no double. auto half = 1 / 2; deduce int y almacena 0, porque 1 / 2 es división entera antes de que auto lo vea siquiera. El tipo sigue al valor:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // división entera -> 0
    auto right = 1.0 / 2;    // double -> 0.5

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

auto descarta la referencia: cuidado con las sorpresas de copia colgante. Si una función devuelve una referencia y la capturas con un auto simple, obtienes una copia, lo que a veces es un auténtico problema de rendimiento en un bucle intensivo (una copia profunda de un objeto grande en cada iteración). Recurre a const auto& cuando quieras decir "mirar, no llevar".

No ocultes el tipo cuando importa. auto result = compute(); está bien cuando el tipo de retorno de compute es evidente por el contexto, pero si quien lee tiene que ir a buscar qué es realmente result, escribir el tipo puede ser la opción más amable. auto sirve para reducir ruido, no para ocultar la intención.

Siguiente: Constantes y const

Ya has visto que auto descarta deliberadamente const salvo que pidas conservarlo, lo que plantea la pregunta evidente: ¿qué garantiza realmente const y cuándo deberías marcar un valor como inmutable en primer lugar? La siguiente página profundiza en const, las expresiones constantes y por qué "hazlo const por defecto" es uno de los hábitos más útiles en C++.