Come si ottiene un lungo senza segno da una stringa?

Question

Qual è il modo più sicuro e migliore per recuperare un long senza segno da una stringa in C++?

Conosco un certo numero di metodi possibili.

In primo luogo, la conversione di un lungo firmato presa da atol.

char *myStr; // Initalized to some value somehow. 
unsigned long n = ((unsigned)atol(myStr)); 

Il problema evidente con questo è, che cosa accade quando il valore memorizzato in myStr è più grande di una firma lunga può contenere? Cosa recupera atol?

La prossima possibilità è usare strtoul.

char *myStr; // Initalized to some value somehow. 
unsigned long n = strtoul(myStr, 0, 10); 

Tuttavia, questo è un po 'complicato per le mie esigenze. Mi piacerebbe una semplice funzione, una stringa, una base lunga senza segno 10 fuori. Inoltre, la gestione degli errori lascia molto a desiderare.

L'ultima possibilità che ho trovato è quella di usare sscanf.

char *myStr; // Initalized to some value somehow. 
unsigned long n = 0; 
if(sscanf(myStr, "%lu", n) != 1) { 
    //do some error handling 
} 

Ancora una volta, la gestione degli errori lascia molto a desiderare e un po 'più complicata di quanto mi piacerebbe.

L'opzione ovvia rimanente è scrivere da solo un wrapper attorno a una delle possibilità precedenti o qualcosa che passa attraverso la stringa e converte manualmente ogni cifra fino a raggiungere ULONG_MAX.

La mia domanda è: quali sono le altre opzioni che il mio google-fu non è riuscito a trovare? Qualunque cosa nella libreria std C++ che convertirà in modo pulito una stringa in una lunga non firmata e genererà eccezioni in caso di errore?

Mi scuso se questo è un problema, ma non ho trovato nessuna domanda che corrispondesse esattamente alla mia.

Answer 1

Un modo per farlo:

stringstream(str) >> ulongVariable; 

Answer 2

È possibile utilizzare strtoul senza alcun problema. La funzione restituisce un long senza segno. Se non è possibile eseguire la conversione, la funzione restituisce 0. Se il valore lungo corretto è fuori intervallo, la funzione restituisce ULONG_MAX e la variabile globale errno è impostata su ERANGE.

Answer 3

template <class T> 
T strToNum(const std::string &inputString, 
      std::ios_base &(*f)(std::ios_base&) = std::dec) 
{ 
    T t; 
    std::istringstream stringStream(inputString); 

    if ((stringStream >> f >> t).fail()) 
    { 
     throw runtime_error("Invalid conversion"); 
    } 
    return t; 
} 


// Example usage 
unsigned long ulongValue = strToNum<unsigned long>(strValue); 
int intValue    = strToNum<int>(strValue); 

int intValueFromHex  = strToNum<int>(strHexValue,std::hex); 
unsigned long ulOctValue = strToNum<unsigned long>(strOctVal, std::oct); 

Answer 4

Jeffrey Stedfast has a beautiful post sulla scrittura di routine int parser per Mono (in C).
Genera codice che utilizza tipi nativi usa (è necessario 32 bit per analizzare 32 bit) e codici di errore per l'overflow.

Answer 5

Se è possibile utilizzare le librerie boost (www.boost.org) cerca nella libreria di conversione - si tratta di un colpo di testa solo includono

#include "boost/lexical_cast.hpp" 

allora tutto quello che dovete fare è

unsigned long ul = boost::lexical_cast<unsigned long>(str); 

Answer 6

modo robusto sarà scrivere una funzione statica e utilizzarlo

bool str2Ulong(const string& str,unsigned long & arValue) 
{ 
    char *tempptr=NULL; 
    arValue=strtoul(str,tempptr,10); 

    return ! (arValue==0 && tempptr==str.c_str()); 

} 

Answer 7

Utilizzare la funzione std incorporata "atol"

Ad esempio std :: input stringa = "1024";

std :: atol (input.c_str());

L'atollo prevede che il parametro sia di tipo c stringa, quindi c_str() lo fa per te.