Comment atoi() fonction en C++ de travail?

Chiffre par chiffre:

Un char *, à proprement parler, est un pointeur vers un char. Un pointeur est une adresse à certains de la place en mémoire. En C/C++ et Java), les chaînes sont constituées de caractères qui peuvent, individuellement, être traités comme des entiers (un octet), grâce à ASCII.

En C (et C++), un pointeur vers un élément d'un certain type est le même comme un pointeur vers une tableau des éléments de ce type. Les chaînes en pur C sont juste des tableaux de chars, avec un '\0' (NUL) à la fin de sorte que vous savez quand vous avez atteint la fin d'une chaîne sans avoir à passer autour de sa longueur partout (un pointeur est seulement une adresse, il sait rien à propos de ce qu'il désigne).

Ignorer la const des mots clés pour maintenant.

La version C de atoi parcourt chaque caractère dans la chaîne. Le *str++ n'plusieurs choses (il est important de comprendre comment il fonctionne, mais c'est une horrible façon d'écrire C). C'est l'équivalent de *(str++). Le str++ renvoie la valeur de str (un pointeur) et incrémente d'une unité (mais il renvoie la vieux valeur!). Le * "déréférence le pointeur, fondamentalement, la lecture dans un char de la mémoire. Cette char est stocké dans digit et puis par rapport à NUL. Les caractères sont stockés dans un format ASCII, ce qui représente chiffres de manière contiguë, donc on peut juste vérifier que digit est entre 0 et 9. Nous savons maintenant que nous sommes de la lecture dans un nouveau chiffre, donc on multiplie la valeur précédente de 10 à la "maj" de la valeur et puis les ajouter dans les chiffres.

Pur C version:

int atoi(const char* str) {
  int num = 0;
  char digit;
  while ((digit = *str++) != '
int atoi(const char* str) {
int num = 0;
char digit;
while ((digit = *str++) != '\0') {
if (digit < '0' || digit > '9') {
return num;  /* No valid conversion possible */
}
num *= 10;
num += c - '0';
}
return num;
}
') {
    if (digit < '0' || digit > '9') {
      return num;  /* No valid conversion possible */
    }
    num *= 10;
    num += c - '0';
  }
  return num;
}

Une chaîne C++ est un objet pour faire face à des chaînes plus facile. Vous pouvez obtenir un char * à partir d'une chaîne C++ avec .c_str().

C++ version (plus probablement un inline appel à la char* version avec "retour atoi(str.c_str());"):

int atoi(const std::string& str) {
  int n = 0;
  for (int i = 0; i < str.size(); i += 1) {
    char digit = str.at(i);   /* Could probably use iterator here,
                               * but this is more explicit. */
    if (digit < '0' || digit > '9') {
      return n;  /* No valid conversion possible. */
    }
    n *= 10;
    n += digit - '0';
  }
  return n;
}

Edit: correction d'un problème où <> pourrait ne pas s'afficher correctement.

Edit: C++ version de chaîne ajouté

Edit: Fixe afin qu'il renvoie 123 dans 123a cas.

Edit: Changé errants num n dans C++ version

OriginalL'auteur Hoa Long Tam

La logique est tout simplement de traiter chaque personnage dans son entier (valeur de réglage pour la position dans la chaîne).

Voici comment je l'ai fait en C#. Même idée générale.

OriginalL'auteur Jonathan Wood

Voici une application qui vérifie les conditions d'erreur et fonctionne pour tous les types d'entiers.

#include <limits>
#include <string>
#include <cctype>
#include <cassert>
#include <type_traits>
template<typename TChar, typename TNumber> bool my_atoi(const std::basic_string<TChar>& str, TNumber& result)
{
typedef std::make_unsigned<TNumber>::type TNumberUnsigned;
//check if result type is integer
assert(std::numeric_limits<TNumber>::is_integer);
auto currChar = str.cbegin();
//use corresponding unsigned type to accumulate number to avoid overflows for numbers such as -128
TNumberUnsigned number = 0;
bool isNegative = *currChar == '-';
if (isNegative) {
//negative numebers can only be parsed into signed types
if (!std::numeric_limits<TNumber>::is_signed)
return false;
++currChar;
}
//empty string or string containing just - sign are not valid integers
if (currChar == str.cend())
return false;
while (currChar != str.cend()) {
auto digit = *currChar - '0';
//check that the next digit is valid
if (digit < 0 || digit > 9)
return false;
//check for overflow
if (number > std::numeric_limits<TNumberUnsigned>::max() / 10)
return false;
number *= 10;
//check for overflow
if (number > std::numeric_limits<TNumberUnsigned>::max() - digit)
return false;
number += digit;
++currChar;
}
if (isNegative) {
//correctly check for negative overflow (-128)
if (number > static_cast<TNumberUnsigned>(std::numeric_limits<TNumber>::max()) + 1)
return false;
result = static_cast<TNumber>(-1 * number);
}
else {
if (number > static_cast<TNumberUnsigned>(std::numeric_limits<TNumber>::max()))
return false;
result = static_cast<TNumber>(number);
}
return true;
}

OriginalL'auteur Ghostrider