atol() v/s. strtol()

Question

What is the difference between atol() & strtol()?

According to their man pages, they seem to have the same effect as well as matching arguments:

long atol(const char *nptr);

long int strtol(const char *nptr, char **endptr, int base);

In a generalized case, when I don't want to use the base argument (I just have decimal numbers), which function should I use?

Answer 1

This thread might help you, http://www.daniweb.com/forums/thread118048.html

Answer 2

strtol provides you with more flexibility, as it can actually tell you if the whole string was converted to an integer or not. atol, when unable to convert the string to a number (like in atol("help")), returns 0, which is indistinguishable from atol("0"):

int main()
{
  int res_help = atol("help");
  int res_zero = atol("0");

  printf("Got from help: %d, from zero: %d\n", res_help, res_zero);
  return 0;
}

Outputs:

Got from help: 0, from zero: 0

strtol will specify, using its endptr argument, where the conversion failed.

int main()
{
  char* end;
  int res_help = strtol("help", &end, 10);

  if (!*end)
    printf("Converted successfully\n");
  else
    printf("Conversion error, non-convertible part: %s", end);

  return 0;
}

Outputs:

Conversion error, non-convertible part: help

Therefore, for any serious programming, I definitely recommend using strtol. It's a bit more tricky to use but this has a good reason, as I explained above.

atol may be suitable only for very simple and controlled cases.

Answer 3

In new code I would always use strtol. It has error handling and the endptr argument allows you to see which part of the string was used.

The C99 standard states about the ato* functions:

Except for the behavior on error,they equivalent to

atoi: (int)strtol(nptr,(char **)NULL, 10)
atol: strtol(nptr,(char **)NULL, 10)
atoll: strtoll(nptr, (char **)NULL, 10)

Answer 4

atol(str) is equivalent to

strtol(str, (char **)NULL, 10);

Use strtol if you want the end pointer (to check whether there are more characters to read or if in fact you have read any at all) or a base other than 10. Otherwise, atol is fine.

Answer 5

If memory serves, strtol() has the added benefit to set the (optional) endptr to point to the first character that could not be converted. If NULL, it is ignored. That way if you're processing a string containing numbers and characters mixed, you could continue.

e.g.,

char buf[] = "213982 and the rest";
char *theRest;
long int num = strtol(buf, &theRest, 10);
printf("%ld\n", num);    /* 213982 */
printf("%s\n", theRest); /* " and the rest" */

Answer 6

atol functionality is a subset of strtol functionality, except that atol provides you with no usable error handling capabilities. The most prominent problem with ato... functions is that they lead to undefined behavior in case of overflow. Note: this is not just a lack of informative feedback in case of an error, this is undefined behavior, i.e. generally an unrecoverable failure.

This means that atol function (as well as all other ato.. functions) is pretty much useless for any serious practical purposes. It was a design mistake and its place is on the junkyard of C history. You should use functions from strto... group to perform the conversions. They were introduced, among other things, to correct the problems inherent in functions of ato... group.