How do you get an unsigned long out of a string?

Question

What's the safest and best way to retrieve an unsigned long from a string in C++?

I know of a number of possible methods.

First, converting a signed long taken from atol.

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

The obvious problem with this is, what happens when the value stored in myStr is larger than a signed long can contain? What does atol retrieve?

The next possibility is to use strtoul.

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

However, this is a little over complicated for my needs. I'd like a simple function, string in, unsigned long base 10 out. Also, the error handling leaves much to be desired.

The final possibility I have found is to use sscanf.

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

Again, error handling leaves much to be desired, and a little more complicated than I'd like.

The remaining obvious option is to write my own either a wrapper around one of the previous possibilities or some thing which cycles through the string and manually converts each digit until it reaches ULONG_MAX.

My question is, what are the other options that my google-fu has failed to find? Any thing in the C++ std library that will cleanly convert a string to an unsigned long and throw exceptions on failure?

My apologies if this is a dupe, but I couldn't find any questions that exactly matched mine.

Solution 1

One way to do it:

stringstream(str) >> ulongVariable;

Solution 2

You can use strtoul with no problem. The function returns an unsigned long. If convertion can not be performed the function return 0. If the correct long value is out of range the function return ULONG_MAX and the errno global variable is set to ERANGE.

Solution 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);

Solution 4

Jeffrey Stedfast has a beautiful post about writing int parser routines for Mono (in C).
It generates code that uses uses native types (you need 32 bit to parse 32 bit) and error codes for overflow.

Solution 5

Use "atol" in-built std function

For example std::string input = "1024";

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

Atol expect parameter to be of type c string, so c_str() does it that for you.

View more solutions

Comments

[Daniel Bingham]

I editted the question to make more clear that I'm working with C-style strings in this case. So this would have to be streamstream(string(myStr)) >> ulongvariable. Which feels wasteful an inefficient to me :/ I'd rather it were something cleaner and more straight forward.

[Daniel Bingham]

Looking for exception style error handling rather than errno style if possible.

[Georg Fritzsche]

Exception style error handling but no overhead through classes? Sounds a bit paradox imo :)

[Daniel Bingham]

Well, functions can do exception style error handling. I just don't want to instantiate two classes I don't need every time I want to convert a long. It seems very wasteful!

[hrnt]

Actually, that is not necessary because std::string has a implicit constructor that takes a C-style string as a parameter. That constructor allows you to write just stringstream("whatever").

[Daniel Bingham]

smack self Of course. Even so, it has the result of instantiating two classes - and all the memory management inherent in that - to do what a simple function with a single internal loop ought to be able accomplish. I wish there were something like that built in the standard library.

[mmx]

Good C++ compilers are aggressive optimizers. Always keep that in mind. I'm not saying it's the fastest way but it should be reasonably fast.

[tster]

@Alcon, don't think about the performance until you have to. Are you sure that this code needs to be extremely fast? Are you sure that this solution isn't extremely fast?

[Noam Rathaus]

The example is wrong, tempptr is (char*), strtoul expects (char**)

[RedFox]

how do I get unsigned long long from char *?