Mot-clé auto en C++ : la déduction de type expliquée avec des exemples

Laissez le compilateur choisir le type

À la page précédente, vous avez vu que toute variable C++ possède un type fixe - int, double, std::string, etc. Écrire ce type à la main convient pour int count = 0;, mais cela devient bruyant dès que les types s'allongent. Le mot-clé auto (C++11 et versions ultérieures) laisse le compilateur déduire le type à partir de la valeur que vous affectez : vous écrivez la valeur une fois et laissez le compilateur compléter le reste.

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

L'idée clé : auto n'est pas du typage dynamique. Chaque variable possède toujours un seul type concret, verrouillé à la compilation. auto vous évite simplement de l'écrire.

Pourquoi auto mérite sa place

Pour des types courts et évidents, auto count = 0; et int count = 0; sont tout aussi lisibles. Là où auto paie vraiment, c'est avec les noms de types longs et répétitifs - le genre qu'on obtient avec les conteneurs et les itérateurs de la bibliothèque standard.

Comparez la version verbeuse à la version avec auto :

// Sans auto - le type est écrit deux fois, en pratique
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// Avec auto - le compilateur connaît déjà le type
auto it = scores.begin();

Les deux déclarent exactement le même type d'itérateur. La seconde est plus facile à lire et ne se désynchronisera pas si vous changez plus tard scores pour un autre conteneur.

La voici dans un programme complet :

#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 dans les boucles for basées sur un intervalle

L'endroit le plus courant où vous rencontrerez auto est la boucle for basée sur un intervalle. Vous ne voulez presque jamais écrire le type de l'élément à la main, et la façon dont vous écrivez le auto détermine si vous obtenez une copie ou une référence.

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

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

    // const auto& - lecture seule, pas de copie. Le choix par défaut habituel pour lire.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Trois variantes que vous verrez, et ce que chacune signifie :

• for (auto x : v) - x est une copie de chaque élément. Économique pour int, gaspilleur pour les gros objets.
• for (auto& x : v) - x est une référence ; vous pouvez modifier les éléments sur place.
• for (const auto& x : v) - x est une référence en lecture seule. Utilisez-la quand vous avez seulement besoin de lire.

Ce programme suivant modifie le conteneur via auto& :

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

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

    for (auto& n : nums) {
        n *= 10;        // modifie l'élément réel
    }

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

Piège : écrivez for (auto n : nums) (sans &) dans cette boucle et n *= 10 ne modifierait silencieusement que la copie, laissant nums intact. Le compilateur ne vous avertira pas - la boucle ne fait simplement rien d'utile.

Ce que auto supprime

Un auto simple déduit le type de la même manière qu'un paramètre de fonction passé par valeur : il supprime le const de premier niveau, les références et volatile. Cela signifie que auto vous donne toujours une copie neuve et modifiable, sauf si vous demandez autre chose.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // le type est int, PAS const int
    copy = 100;             // parfaitement légal - le const a été supprimé

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

Si vous voulez conserver le const ou éviter la copie, vous ajoutez les qualificateurs vous-même. Le principe consiste à décorer auto exactement comme vous décoreriez n'importe quel type :

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

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

    const auto& ref = name;   // const std::string& - pas de copie, lecture seule
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // erreur : ref est const
    return 0;
}

Donc auto déduit le type de base ; &, const et * sont des réglages que vous ajoutez par-dessus. auto est le type, const auto& est une référence en lecture seule vers celui-ci.

Erreurs courantes et pièges

auto supprime l'effort de frappe, pas le besoin de comprendre les types. Quelques pièges attrapent les débutants :

Vous devez initialiser. auto n'a rien à déduire à partir d'une déclaration vide, donc ceci est une erreur de compilation pure et simple :

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // ça va

Les littéraux entiers sont des int, pas des double. auto half = 1 / 2; déduit int et stocke 0, parce que 1 / 2 est une division entière avant que auto ne le voie. Le type suit la valeur :

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // division entière -> 0
    auto right = 1.0 / 2;    // double -> 0.5

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

auto supprime la référence - attention aux surprises de copie pendante. Si une fonction renvoie une référence et que vous la capturez avec un auto simple, vous obtenez une copie, ce qui est parfois un véritable problème de performance dans une boucle critique (une copie profonde d'un gros objet à chaque itération). Recourez à const auto& quand vous voulez dire « regarder, pas emporter ».

Ne masquez pas le type quand il compte. auto result = compute(); convient quand le type de retour de compute est évident d'après le contexte, mais si un lecteur doit partir à la chasse pour savoir ce qu'est réellement result, écrire le type peut être le choix le plus aimable. auto sert à réduire le bruit, pas à masquer l'intention.

Suite : Constantes et const

Vous avez maintenant vu que auto supprime délibérément const à moins que vous ne demandiez à le conserver - ce qui soulève la question évidente : que garantit réellement const, et quand devriez-vous marquer une valeur comme immuable en premier lieu ? La page suivante creuse const, les expressions constantes et pourquoi « le mettre en const par défaut » est l'une des habitudes les plus utiles en C++.