HOWTO · C++

Converti array di caratteri in Int in C++

Questo articolo illustra i modi per convertire un array char in tipo int in C++

In questa pagina

Un array char terminato da null può contenere testo che rappresenta un numero intero. C++ offre diversi modi per analizzare questo testo, ma le funzioni differiscono per il modo in cui segnalano gli errori e per la possibilità di accettare un prefisso numerico seguito da altri caratteri. Scegli in base all’affidabilità dell’input e alla necessità che l’intero array contenga un numero valido.

Gli esempi usano numeri decimali. La conversione corretta di un prefisso non significa necessariamente che siano stati consumati tutti i caratteri: per esempio, analizzando "23323tail" si può ottenere 23323, lasciando tail non analizzato. Se l’intero input deve essere numerico, controlla la posizione in cui si è fermato il parser oltre al risultato della conversione.

Usa la funzione std::strtol per convertire un array char in un int

std::strtol analizza una sequenza di caratteri terminata da null e restituisce un long. Il terzo argomento seleziona la base: usa 10 per il sistema decimale, 16 per quello esadecimale oppure 0 per dedurre la base da un prefisso. Se la base è diversa da zero, l’intervallo valido va da 2 a 36.

Il secondo argomento riceve un puntatore al primo carattere non consumato. Se punta ancora all’inizio dell’input, non è stata analizzata alcuna cifra. Se punta al carattere null terminatore, è stata consumata l’intera stringa. Imposta errno a zero prima della chiamata e controlla successivamente ERANGE per rilevare un risultato fuori dall’intervallo di long. Poiché il risultato è di tipo long, prima di memorizzarlo in un int confrontalo anche con std::numeric_limits<int>::min() e max().

Esegui questo esempio. Usa testo decimale memorizzato in un array di caratteri terminato da null e stampa l’intero analizzato.

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

#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’esecuzione fornita per questo caso valido è terminata con codice 0 e ha prodotto:

23323

L’esecuzione riguarda solo questo input valido: non dimostra il comportamento in caso di conversioni non riuscite o valori fuori intervallo. Per gli input usati in produzione, mantieni i controlli: permettono di distinguere l’assenza di conversione, i caratteri residui, un errore di intervallo per long e un valore non rappresentabile come int.

Usa la funzione std::atoi per convertire un array char in un int

std::atoi è un’opzione concisa quando l’input è già affidabile e ben formato:

int value = std::atoi(input);

Accetta gli spazi iniziali e un segno facoltativo, quindi analizza le cifre decimali. Come altri parser di prefissi, può fermarsi davanti a un carattere non numerico e ignorare quelli successivi. Non offre un modo affidabile per distinguere uno zero valido da una conversione non riuscita, né un canale utile per segnalare errori di intervallo. Se il valore analizzato non è rappresentabile come int, il comportamento è indefinito; non usare std::atoi con input numerici non verificati o non affidabili. Usa std::strtol se l’input potrebbe essere malformato o fuori intervallo, oppure se servono diagnostica della conversione e un controllo esplicito dell’intervallo di int.

Usa la funzione std::sscanf per convertire un array char in un int

std::sscanf applica un formato al testo e indica quante conversioni sono riuscite. Per un singolo intero, verifica che il valore restituito sia 1 prima di usare la variabile di destinazione:

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

%d accetta gli spazi iniziali e un segno facoltativo, quindi legge le cifre decimali. Può analizzare correttamente un prefisso lasciando testo residuo non letto; se è necessario consumare l’intero input, aggiungi un controllo del formato o usa un altro metodo di parsing. La destinazione deve essere un oggetto int reale e scrivibile; non va letta se il conteggio delle conversioni non conferma che ne è avvenuta una. Quel conteggio non rende sicuro un risultato non rappresentabile: se il valore corrispondente non può essere rappresentato come int, il comportamento è indefinito. Non usare %d con input numerici non verificati o non affidabili che potrebbero essere fuori intervallo. Per questo semplice caso, std::strtol rende più espliciti i controlli della posizione finale e dell’intervallo.

Usa un ciclo per convertire un array char in un int

Un ciclo è adatto quando la sintassi accettata è intenzionalmente personalizzata. Definisci prima tale sintassi. Per esempio, un parser decimale potrebbe accettare un + o - iniziale facoltativo, richiedere almeno una cifra e rifiutare ogni altro carattere. Prima di ciascuna operazione di moltiplicazione e somma deve anche verificare che la cifra successiva resti entro l’intervallo intero scelto. In caso contrario, un overflow con segno può produrre un risultato errato o causare un comportamento indefinito.

Non ignorare i caratteri non numerici per aggiungere le cifre successive: trasformare "23tail4" in 234 significa filtrare i caratteri, non analizzare un intero. Un parser personalizzato completo deve gestire la posizione del segno, la validità delle cifre, il consumo dell’intero input e l’overflow. Se queste regole personalizzate non sono necessarie, usa invece std::strtol e il relativo puntatore alla fine della conversione.

Conclusione

Per una conversione generica, preferisci std::strtol: fornisce la posizione in cui si interrompe l’analisi e consente di rilevare gli errori di intervallo di long; inoltre, prima della conversione, il risultato può essere confrontato con i limiti di int. Usa std::atoi solo con input affidabili e ben formati, quando non servono diagnostiche dettagliate. Scegli std::sscanf quando è utile il parsing formattato e controlla il conteggio delle conversioni. Scrivi un ciclo se il programma richiede una grammatica di input volutamente diversa e implementa esplicitamente i controlli di segno, cifre, consumo completo e overflow.