std:: strtol, std:: strtoll

Interprète une valeur entière dans une chaîne d'octets pointée par str .

Ignore tous les caractères d'espacement (identifiés en appelant std::isspace ) jusqu'au premier caractère non-espace, puis prend autant de caractères que possible pour former une représentation valide d'un nombre entier en base-n (où n= base ) et les convertit en une valeur entière. La valeur entière valide se compose des parties suivantes :

• (optionnel) signe plus ou moins
• (optionnel) préfixe ( 0 ) indiquant la base octale (s'applique uniquement lorsque la base est 8 ou ​ 0 ​ )
• (optionnel) préfixe ( 0x ou 0X ) indiquant la base hexadécimale (s'applique uniquement lorsque la base est 16 ou ​ 0 ​ )
• une séquence de chiffres

L'ensemble des valeurs valides pour la base est {0, 2, 3, ..., 36} . L'ensemble des chiffres valides pour les entiers en base 2 est {0, 1} , pour les entiers en base 3 est {0, 1, 2} , et ainsi de suite. Pour les bases supérieures à 10 , les chiffres valides incluent des caractères alphabétiques, commençant par Aa pour les entiers en base 11 , jusqu'à Zz pour les entiers en base 36 . La casse des caractères est ignorée.

Des formats numériques supplémentaires peuvent être acceptés par la locale C locale actuellement installée.

Si la valeur de base est ​ 0 ​ , la base numérique est auto-détectée : si le préfixe est 0 , la base est octale, si le préfixe est 0x ou 0X , la base est hexadécimale, sinon la base est décimale.

Si le signe moins faisait partie de la séquence d'entrée, la valeur numérique calculée à partir de la séquence de chiffres est niée comme si par unary minus dans le type de résultat.

La fonction définit le pointeur pointé par str_end pour pointer vers le caractère suivant le dernier caractère interprété. Si str_end est un pointeur nul, il est ignoré.

Si la str est vide ou n'a pas la forme attendue, aucune conversion n'est effectuée, et (si str_end n'est pas un pointeur nul) la valeur de str est stockée dans l'objet pointé par str_end .

Paramètres

Valeur de retour

• Si l'opération réussit, une valeur entière correspondant au contenu de str est retournée.
• Si la valeur convertie dépasse la plage du type de retour correspondant, une erreur de dépassement se produit (en définissant errno à ERANGE ) et LONG_MAX , LONG_MIN , LLONG_MAX ou LLONG_MIN est retournée.
• Si aucune conversion ne peut être effectuée, ​ 0 ​ est retourné.

Exemple

#include <cerrno>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <string>
int main()
{
    const char* p = "10 200000000000000000000000000000 30 -40";
    std::cout << "Parsing " << std::quoted(p) << ":\n";
    for (;;)
    {
        // errno peut être défini sur n'importe quelle valeur non nulle par un appel de fonction de bibliothèque
        // indépendamment de la présence d'une erreur, donc il doit être réinitialisé
        // afin de vérifier l'erreur définie par strtol
        errno = 0;
        char* p_end{};
        const long i = std::strtol(p, &p_end, 10);
        if (p == p_end)
            break;
        const bool range_error = errno == ERANGE;
        const std::string extracted(p, p_end - p);
        p = p_end;
        std::cout << "Extracted " << std::quoted(extracted)
                  << ", strtol returned " << i << '.';
        if (range_error)
            std::cout << "\n  Range error occurred.";
        std::cout << '\n';
    }
}

Parsing "10 200000000000000000000000000000 30 -40":
Extracted "10", strtol returned 10.
Extracted " 200000000000000000000000000000", strtol returned 9223372036854775807.
  Range error occurred.
Extracted " 30", strtol returned 30.
Extracted " -40", strtol returned -40.

Voir aussi