Comment convertir un tableau de caractères en Int en C++

Un tableau char terminé par un caractère nul peut contenir du texte représentant un entier. C++ propose plusieurs façons d’analyser ce texte, mais les fonctions diffèrent par leur manière de signaler les erreurs et leur capacité à accepter un préfixe numérique suivi d’autres caractères. Choisissez une méthode selon que l’entrée est fiable et que le tableau entier doit contenir un nombre valide.

Les exemples utilisent des nombres décimaux. Une conversion réussie d’un préfixe ne signifie pas nécessairement que tous les caractères ont été consommés : par exemple, l’analyse de "23323tail" peut produire 23323 et laisser tail sans traitement. Si toute l’entrée doit être numérique, vérifiez la position où l’analyse s’est arrêtée ainsi que le résultat de la conversion.

Utiliser la fonction std::strtol pour convertir un tableau char en int

std::strtol analyse une séquence de caractères terminée par un caractère nul et renvoie un long. Son troisième argument détermine la base : utilisez 10 en décimal, 16 en hexadécimal ou 0 pour déduire la base à partir d’un préfixe. Pour les bases autres que zéro, la plage valide va de 2 à 36.

Le deuxième argument reçoit un pointeur vers le premier caractère qui n’a pas été consommé. S’il pointe toujours vers le début de l’entrée, aucun chiffre n’a été analysé. S’il pointe vers le caractère nul final, la chaîne entière a été consommée. Initialisez errno à zéro avant l’appel et vérifiez ensuite si sa valeur est ERANGE pour détecter un résultat hors de la plage de long. Comme le résultat est un long, comparez-le aussi à std::numeric_limits<int>::min() et à max() avant de le stocker dans un int.

Exécutez cet exemple. Il utilise un nombre décimal stocké dans un tableau de caractères terminé par un caractère nul et affiche l’entier analysé.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <cerrno>
#include <cstdlib>
#include <iostream>
#include <limits>

int main() {
  const char input[] = "23323";
  char* end = nullptr;
  errno = 0;
  const long parsed = std::strtol(input, &end, 10);

  if (end == input || *end != '\0' || errno == ERANGE ||
      parsed < std::numeric_limits<int>::min() ||
      parsed > std::numeric_limits<int>::max()) {
    std::cout << "Could not convert the complete input.\n";
    return 0;
  }

  const int value = static_cast<int>(parsed);
  std::cout << value << '\n';
}

L’exécution fournie pour ce cas réussi s’est terminée avec le code 0 et a produit :

23323

Cette exécution ne couvre que cette entrée valide ; elle ne permet pas de déterminer le comportement en cas d’échec de conversion ou de dépassement de plage. Pour les entrées utilisées en production, conservez les vérifications : elles permettent de distinguer l’absence de conversion, les caractères restants, un dépassement de la plage de long et une valeur qui ne tient pas dans un int.

Utiliser la fonction std::atoi pour convertir un tableau char en int

std::atoi est une option concise lorsque l’entrée est déjà fiable et correctement formée :

int value = std::atoi(input);

La fonction accepte les espaces en début d’entrée et un signe facultatif, puis analyse les chiffres décimaux. Comme les autres analyseurs de préfixe, elle peut s’arrêter au premier caractère non numérique et ignorer la suite. Elle ne permet pas de distinguer de façon fiable un zéro valide d’un échec de conversion et ne fournit pas de moyen utile de signaler un dépassement de plage. Si la valeur analysée ne peut pas être représentée par un int, le comportement est indéfini ; n’utilisez pas std::atoi avec une entrée numérique non vérifiée ou non fiable. Utilisez std::strtol si l’entrée peut être mal formée ou hors plage, ou si l’appelant a besoin d’informations sur la conversion et d’une vérification explicite des limites de int.

Utiliser la fonction std::sscanf pour convertir un tableau char en int

std::sscanf applique un format au texte et indique combien de conversions ont réussi. Pour un entier, vérifiez que la valeur renvoyée est 1 avant d’utiliser la variable de destination :

int value = 0; int converted = std::sscanf(input, "%d", &value);

%d accepte les espaces en début d’entrée et un signe facultatif, puis lit les chiffres décimaux. La conversion peut réussir sur un préfixe tout en laissant du texte à la suite ; si l’entrée entière doit être consommée, vérifiez également le format ou utilisez une autre méthode d’analyse. La destination doit être un véritable objet int modifiable, et ne doit pas être lue si le nombre de conversions ne confirme pas qu’une conversion a eu lieu. Ce nombre ne rend pas sûre une valeur impossible à représenter : si la valeur correspondante ne tient pas dans un int, le comportement est indéfini. N’utilisez pas %d avec une entrée numérique non vérifiée ou non fiable qui risque d’être hors plage. Pour cette tâche simple, std::strtol rend plus explicites la vérification de la position d’arrêt et celle de la plage.

Utiliser une boucle pour convertir un tableau char en int

Une boucle convient lorsque la syntaxe acceptée est volontairement personnalisée. Commencez par la définir. Par exemple, un analyseur décimal peut accepter un + ou un - initial facultatif, exiger au moins un chiffre et rejeter tout autre caractère. Avant chaque multiplication et addition, il doit aussi vérifier que le chiffre suivant ne fera pas dépasser la plage d’entiers choisie. Sinon, un dépassement d’entier signé peut fausser le résultat ou entraîner un comportement indéfini.

Ne sautez pas les caractères non numériques pour ajouter les chiffres suivants : transformer "23tail4" en 234, c’est filtrer des caractères, pas analyser un entier. Un analyseur personnalisé complet doit gérer la position du signe, la validation des chiffres, la consommation de toute l’entrée et les dépassements. À moins que ces règles personnalisées soient nécessaires, utilisez plutôt std::strtol et son pointeur de fin.

Conclusion

Pour une conversion générale, préférez std::strtol : la fonction fournit la position d’arrêt et permet de détecter les dépassements de la plage de long ; son résultat peut ensuite être comparé aux limites de int avant la conversion. Utilisez std::atoi uniquement avec une entrée fiable et correctement formée, lorsque des diagnostics détaillés ne sont pas nécessaires. Choisissez std::sscanf si l’analyse formatée est utile, en vérifiant son nombre de conversions. Écrivez une boucle si le programme doit accepter une grammaire d’entrée particulière, et implémentez explicitement la gestion du signe, la validation des chiffres, la consommation complète de l’entrée et les vérifications de dépassement.