Convert string to int

[SterlingM]

Presently, I am using the atoi() function. But I don't want to use this because if the user inputs a value that isn't numeric, it returns 0. So I can't really check if they entered an actual 0 or an incorrect value. What are alternatives to using atoi?

[hoxsiew]

You could use strtol(). It takes a pointer to the part that failed. You can use pointer arithmetic to determine how the conversion proceded:

http://msdn.microsoft.com/en-us/libr...8VS.80%29.aspx

Or just use a std::stringstream

[nbaztec]

Presently, I am using the atoi() function. But I don't want to use this because if the user inputs a value that isn't numeric, it returns 0. So I can't really check if they entered an actual 0 or an incorrect value. What are alternatives to using atoi?

strtol() for long int
strtoul() for long unsigned int
strtod() for double

[PredicateNormative]

If you are using C++, you could use boost lexical. If you are using C++, but don't want to be dependent on boost, then you could use stringstream to write your own conversion function. For example, this should do what you need:

template <typename T> 
T string_to(const std::string &s) 
{ 
  T result; 
 
  //check for the boolean 'true' keyword  
  if (s.find("true")!=std::string::npos) 
  { 
    result = 1; 
  }  
  //check for the boolean 'false' keyword 
  else if (s.find("false")!=std::string::npos) 
  { 
    result=0; 
  } 
  else 
  { 
     std::stringstream ss; 
 
    //Check for Hex input 
    if(s.size()>1) 
    { 
      //If the first two characters are '0x' then the input is 
      //a hexidecimal input and therefore the stringstream 
      //base needs to be set to base 16. 
      if(s[0]=='0' && tolower(s[1])=='x') 
      { 
        ss << std::setbase(16);  
      } 
    } 
 
    ss.str(s); 
 
    if (!(ss >> result)) 
    { 
      throw std::runtime_error("string_to: Failed to convert string to destination type"); 
    } 
  } 
 
  //Return the resulting value. 
  return result; 
}

You can use it like:

int value = string_to<int>("123");

The above works for conversions from a string to other types too (bool, float etc...).

[ninja9578]

I wrote this for a scripting language. It converts them to long doubles, but you can cast that down to an int easily. Admittedly, it's a little messy, but it's stable and fast. I probably send a million conversions through it a week.

/*
 *  Number_Functions.cpp
 *  Math
 *
 *  Created by Wallace on 12/5/09.
 *  Copyright 2009 LiveTechnology. All rights reserved.
 *
 */

#include "Number_Functions.h"
#include <sstream>
#include <iomanip>
#include <cmath>
#include <iostream>

string LS_INFINITY = "Infinity";
string NEG_LS_INFINITY = "-Infinity";
string LS_UNDEFINED = "NaN";
long double Infinity = 1.0f / 0.0f;
long double NaN = sqrt(-1);

long double e = 2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274f;
long double pi = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679f;

char NumberChars[] = {"0123456789"};
char HexChars[] = {"012345679ABCDEFabcdef"};

int Fixed_Precision = 12;

long double StringToHex(const string & str){
    long long tout = 0;
    char * p = (char*)str.c_str();
    p += 2;  //go past the 0 and x
    while(*p){
	   tout = tout << 4;  //a hex character represents 4 bits
	   unsigned char ch = *p;
	   if (ch < 58){  //0-9
		  tout |= ch - 48;
	   } else if (ch < 71){ //A-F
		  tout |= ch - 55;
	   } else {  //a-f
		  tout |= ch - 87;
	   }
	   ++p;
    }
    return (long double)tout;
}

long double PercentToNumber(const string & s, size_t len, const long double & outof){
    //len is the length of the NUMBER (exclusing the &#37;)
    long double res = atof(s.substr(0, len).c_str());
    return res * outof / 100.0f;   
}

bool NumberFunctions::CheckNonNumberChar(const string & str, size_t pp, long double & out, const long double & outof, bool AllowDecimals){
    /*
	   This is for when it found a character that is not numeric, it could still be 
		  scientific notation
		  a decimal place
		  a percentage
    */
    switch (str[pp]){
	   case 'e':  //scientific notation, or just an e?
		  switch (str[pp + 1]){
			 case '+':
				if (str.find_first_not_of(NumberChars, pp + 2) == string::npos){
				    out = atof(str.c_str());
				    return true;
				}
				break;
			 case '-':  //initial negation was already compensated for, so pp can never be 0
				if (str.find_first_not_of(NumberChars, pp + 2) == string::npos){ 
				    out = atof(str.c_str());
				    return true;
				}
				break;
		  }
		  break;
	   case '.':
		  if (!AllowDecimals) return false;  //already been through this once, it's the second decimal
		  pp = str.find_first_not_of(NumberChars, pp + 1);
		  if (pp == string::npos) return true;
		  return CheckNonNumberChar(str, pp, out, outof, false);
	   case '%':
		  size_t len = str.length();
		  if (pp == len){
			 out = PercentToNumber(str, len, outof);
			 return true;
		  }
    } 
    return false;
}

string NumberFunctions::ToString(long double n){
    if (n == Infinity) return LS_INFINITY;
    if (n == -Infinity) return NEG_LS_INFINITY;
    stringstream out;
    out << setprecision(Fixed_Precision) << n;
    return out.str();
}

/*
    <x> = (0-9)
    <h> = (<x> | (A-F) | (a-f))*
    <d> = (<x>*).(<x>*)
    <c> = Pi | PI | pi | e
    Number = ([-](<d> | Infinity | 0x<h> | <d>e[-]<x>)) | NaN | <c>
*/

long double NumberFunctions::ToNumber(const string & s, const long double & outof){
    if (s == "e") return e;
    if ((s == "Pi") || (s == "pi") || (s == "PI")) return pi;
    return ToNumber_NoConstants(s, outof);
}

long double NumberFunctions::ToNumber_NoConstants(const string & s, const long double & outof){
    if (((s[0] == '0') && (s[1] == 'x')) ||
	   ((s[0] == '-') && (s[1] == '0') && (s[2] == 'x'))){
	   return StringToHex(s);
    } else {
	   size_t len = s.length() - 1;
	   if (s[len] == '%'){
		  return PercentToNumber(s, len, outof);
	   }
    }
    if (s == LS_INFINITY) return Infinity;
    if (s == NEG_LS_INFINITY) return -Infinity;
    if (s == LS_UNDEFINED) return NaN;
    return atof(s.c_str());
}

bool NumberFunctions::IsNumber(const string & str, long double & out, const long double & outof){
    if (str == "e"){
	   out = e;
	   return true;
    }
    if ((str == "Pi") || (str == "pi") || (str == "PI")){
	   out = pi;
	   return true;
    }
    return IsNumber_NoConstants(str, out, outof);
}

bool NumberFunctions::IsNumber_NoConstants(const string & str, long double & out, const long double & outof){
    if (str == LS_INFINITY){
	   out = Infinity;
	   return true;
    }
    if (str == NEG_LS_INFINITY){
	   out = -Infinity;
	   return true;
    }
    if (str[0] == '-'){
	   if ((str[1] == '0') && (str[2] == 'x')){
		  if (str.find_first_not_of(HexChars, 3) != string::npos) return false;
		  out = StringToHex(str);
		  return true;
	   } else {  //negative, non hex, keep looking for failure
		  size_t pp = str.find_first_not_of(NumberChars, 1);
		  if (pp != string::npos) return CheckNonNumberChar(str, pp, out, outof);
	   }
    } else if ((str[0] == '0') && (str[1] == 'x')){
	   if (str.find_first_not_of(HexChars, 2) != string::npos) return false;
	   out = StringToHex(str);
	   return true;
    } else {
	   size_t pp = str.find_first_not_of(NumberChars);
	   if (pp != string::npos) return CheckNonNumberChar(str, pp, out, outof);
    }
    out = atof(str.c_str());
    return true;
}

Here is the grammar:

    <x> = (0-9)
    <h> = (<x> | (A-F) | (a-f))*
    <d> = (<x>*).(<x>*)
    <c> = Pi | PI | pi | e
    Number = ([-](<d> | Infinity | 0x<h> | <d>e[-]<x>)) | NaN | <c>

No octal support, but I've never actually seen a programmer use an octal value :\

[Joeman]

Presently, I am using the atoi() function. But I don't want to use this because if the user inputs a value that isn't numeric, it returns 0. So I can't really check if they entered an actual 0 or an incorrect value. What are alternatives to using atoi?

I simple check if str is '0' would probably work.

int satoi( const char* Str, bool& Err )
{
    int Num = atoi( Str );
    Err = !Num && *Str != '0';
    return Num;
}

or you just

int satoi( const char* Str )
{
    int Num = atoi( Str );
    if( !Num && *Str != '0' ) throw( "String to int failed" );
    return Num;
}

[Lindley]

long double e = 2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274f;
long double pi = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679f;

I love the fact that you included about a thousand digits, and then put "f" on the end to indicate the literal should be a single-precision float, effectively discarding the majority of those digits.....

[ninja9578]

O.o Oops. Uh, that should be ld. I don't know how I missed that one :\ I think I had less digits there once, then added the others just for the hell of it.

[nbaztec]

I love the fact that you included about a thousand digits, and then put "f" on the end to indicate the literal should be a single-precision float, effectively discarding the majority of those digits.....

lol.

[kempofighter]

This is one of those questions where an appropriate answer could have been to just make a referral to the FAQ since this question is one that has been asked so often. It would save you all a lot of typing!
http://www.codeguru.com/forum/showthread.php?t=231054