Atoi / Atol - results in 0

Question

I'm building quick "Configuration Reader" which reads settings from files. Problem is, that function returns "800" character string and atol with that input returns 0. I'm not sure what I'm doing wrong.

So, this is how it roughly looks like:

char *txtval=GetParamFromLine("WINDOW_WIDTH");
val = atol(txtval); 

char* GetParamFromLine(char*parameter)
{
   char text[16];
   //
   // do the reading procedure and fill the text
   //
   return text;
}

Result: atol(text) = 0 (where text = "800" )

Thanks for your help!

Answer 1

You need to have "text" stored on the heap instead of the stack. Otherwise the variable goes of scope when the function ends, and you'll have undefined behavior trying to access that segment of memory. You can either allocate memory on the heap and then free it when you're done,

char *txtval=GetParamFromLine("WINDOW_WIDTH");
val = atol(txtval); 
free txtval;

// Caller is responsible for freeing returned buffer
char* GetParamFromLine(char*parameter)
{
   char text* = malloc(sizeof(char)*16);
   //
   // do the reading procedure and fill the text
   //
   return text;
}

Or alternatively pass in a pointer to a buffer where the result should be stored.

char txtval[16];
GetParamFromLine("WINDOW_WIDTH", txtval);
val = atol(txtval); 

void GetParamFromLine(char *parameter, char *resultBuffer)
{
   //
   // do the reading procedure and fill the text into resultBuffer
   //
}

Answer 2

You're returning a pointer to a locally scoped variable. The memory text goes out of scope after the function call, so a pointer to it has no meaning as the memory will be reclaimed...

You'll need to allocate some longer-term storage for text, or combine the GetParamFromLine and atol into the same function.

Answer 3

Make text static:

char* GetParamFromLine(char*parameter)
{
    static char text[16];
    ... do something
    return text;
}

Your version is using a stack-resident version that will probably be overwritten before it is used. The static storage class specifier ensures that the

That returned buffer will only be good up until the next call to GetParameterFromLine.

It's better, in general, for the caller to provide the buffer and a buffer size as arguments to a function like this.

char *GetParamFromLine(const char *parameter, char *text, size_t text_size)
{
    ... do something
    return text;
}

The "do something" code should carefully observe that size. You will have to decide whether to truncate the parameter, return an empty string, return a NULL pointer, or whatever if the actual data is longer than the buffer.

Answer 4

The problem is caused by returning a pointer to a local variable. When the function GetParamFromLine returns the variable text goes out of scope. The pointer returned is no longer valid, resulting in undefined behavior. You have to return the data in some other way, for example:

std::string txtval=GetParamFromLine("WINDOW_WIDTH");
val = atol(txtval.c_str());

std::string GetParamFromLine(char*parameter)
{
   char text[16];
   //
   // do the reading procedure and fill the text
   //
   return std::string(text);
}

Changing the return type from a pointer to a local to std::string alleviates the problem of returning a pointer to a local variable. The resources used by std::string are managed by the object and are cleaned up automatically.

As an alternative you could remove the atol call as well and use a std::istringstream instead. One benefit is that this allows for better error reporting:

std::string txtval=GetParamFromLine("WINDOW_WIDTH");
std::istringstream iss(txtval);
int val( 0 );
iss >> val;

Now if you really want to go over the top you could combine both retrieval of the string and conversion to an integral data type, and parameterize the return type of this new function template:

template<typename T>
T GetValueFromLine(const std::string& param) {
    std::string txtval=GetParamFromLine(param.c_str);
    std::istringstream iss(txtval);
    T val = T();
    iss >> val;
    return val;
}

With this template you can do the following:

long wndWidth = GetValueFromLine<long>("WINDOW_WIDTH");
bool showInfo = GetValueFromLine<bool>("SHOW_INFO");
....

Note: Error handling omitted.