Le mot-clé auto en C++ utilisé pour l'inférence de type

1. le mot clé auto en C++
2. Utiliser auto avec des fonctions en C++
3. Utiliser auto avec des variables en C++
4. Utiliser auto avec les itérateurs en C++
5. Utiliser auto avec les paramètres de fonction en C++
6. Erreurs dans l’utilisation du mot-clé auto en C++
7. Conclusion

Ce tutoriel abordera le mot-clé auto introduit en C++ 11. Nous examinerons différents exemples pour comprendre ses cas d’utilisation et les erreurs courantes commises lors de son utilisation.

le mot clé auto en C++

Le mot clé auto dans la version C++ 11 fait partie de la fonctionnalité Type inference. L’inférence de type consiste à déduire le type de données d’une fonction ou d’une variable au moment de la compilation.

Nous n’avons donc pas à spécifier le type de données que le compilateur peut déduire automatiquement au moment de la compilation. L’instruction return nous aide à déduire le type de données de retour pour les fonctions.

Alors que, dans le cas des variables, l’initialisation aide à déterminer le type de données.

Utiliser auto avec des fonctions en C++

#include <iostream>
using namespace std;

auto division() {
  double a = 55.0;
  double b = 6.0;
  double ans = a / b;
  return ans;
}

int main() { cout << division(); }

Production:

9.16667

Ici, l’instruction return aide le compilateur à déduire le type de retour de notre fonction division(). Puisque la fonction retourne ans, un type double, le compilateur en déduit que auto doit être remplacé par un double.

Utiliser auto avec des variables en C++

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

int main() {
  auto x = 10;
  auto y = 10.4;
  auto z = "iron man";

  cout << x << endl;
  cout << y << endl;
  cout << z << endl;
}

Production:

10
10.4
iron man

En se basant sur le côté droit de l’instruction, aussi appelé initialiseurs, le compilateur déduit le type de la variable.

Utiliser auto avec les itérateurs en C++

Lorsqu’il s’agit de conteneurs STL tels que vector, set ou map, le mot-clé auto est très utilisé pour les parcourir. Nous pouvons minimiser la perte de temps en sautant la longue déclaration de l’itérateur.

#include <bits/stdc++.h>
using namespace std;

int main() {
  vector<int> v{22, 14, 15, 16};

  vector<int>::iterator it = v.begin();  // without auto
  auto it2 = v.begin();

  while (it2 != v.end()) {
    cout << *it2 << " ";
    it2++;
  }
  cout << endl;

  map<int, int> mp;
  mp.insert(pair<int, int>(1, 40));
  mp.insert(pair<int, int>(2, 30));
  mp.insert(pair<int, int>(3, 60));
  mp.insert(pair<int, int>(4, 20));

  map<int, int>::iterator vt = mp.begin();  // without auto
  auto vt2 = mp.begin();

  while (vt2 != mp.end()) {
    cout << vt2->first << " -> " << vt2->second << endl;
    vt2++;
  }
  cout << endl;
}

Production:

22 14 15 16
1 -> 40
2 -> 30
3 -> 60
4 -> 20

On observe la différence entre utiliser le auto et non. Sans auto, il faut spécifier explicitement le type d’itérateur, ce qui est fastidieux car les instructions sont assez longues.

Utiliser auto avec les paramètres de fonction en C++

En C++, nous devons spécifier les paramètres de la fonction à chaque fois, mais cela peut être simplifié en utilisant auto.

#include <bits/stdc++.h>
using namespace std;

void myfunc(auto x, auto str) { cout << x << " " << str << endl; }

int main() {
  int x = 10;
  string str = "Iron Man";
  myfunc(x, str);
}

Production:

10 Iron Man

La déduction des types de données se produit lors de l’appel de la fonction. Par conséquent, la correspondance des variables se produit et le compilateur détermine les types de données exacts pour tous les arguments.

Erreurs dans l’utilisation du mot-clé auto en C++

Confusion entre entier et booléen

En C++, nous savons que les valeurs booléennes sont initialisées par 0 ou 1. Maintenant, cela pourrait créer une certaine confusion lors du débogage.

#include <bits/stdc++.h>
using namespace std;

int main() { auto temp = 0; }

Déclarations multiples à l’aide du mot-clé auto

Nous déclarons les variables en une seule fois pour gagner du temps, mais cela peut créer des problèmes si les deux sont de types différents.

#include <bits/stdc++.h>
using namespace std;

int main() { auto x = 10, y = 35.66; }

Production:

[Error] inconsistent deduction for 'auto': 'int' and then 'double'

Lorsque nous compilons le code ci-dessus dans un compilateur, nous obtenons une erreur, et cela se produit parce que le compilateur est confus.

Conclusion

Nous avons compris que le mot clé auto permet de gagner beaucoup de temps lors de l’écriture de code de base, en se concentrant sur les parties les plus intensives et les plus complexes d’un programme. Bien que très utile, nous devons faire attention à la façon dont nous l’utilisons.