Stack array variable cleanup

Question

I am using the following function to read from a file.

void read_file(){
   char buf[BUF_SIZE];
   // file is a vraiable defined and assigned during initialization
   int numread = pread(file->fd, buf, BUF_SIZE, file->curpos);
   // other logic follows
   file->buffer += buf;
}

The following function still in the same class evaluates the contents of the buffer read from file.

void evaluate(){
   read_file();
   //evaluate the file->buffer contents
}

From my understanding the stack variables are automatically 'removed' when a function exits but I cant seem to comprehend why the buf variable in the read_file() function is not being cleared on consecutive call to evauluate() .

For instance if I do;

int main(){
   evaluate(); // first call works as expected 
   evaluate(); // second call buf variable still has contents from previous call
   return 0;
}

I would appreciate a hint to the right direction in solving this. Thanks in advance.

You didn’t initialize them. They have unspecified contents. — Incomputable, Jan 10 '18 at 11:51
the memory is freed but not cleared. you're seeing "garbage". you can do something like char buf[BUF_SIZE] = {0}; to initialize it with zeros — user2717954, Jan 10 '18 at 11:52
The contents of a destroyed variable doesn't have to go away *immediately*. — Bo Persson, Jan 10 '18 at 11:54
If file->buffer actually is a std::string, += should be fine -- *if*... — Aconcagua, Jan 10 '18 at 11:54
Must read: https://stackoverflow.com/questions/6441218/can-a-local-variables-memory-be-accessed-outside-its-scope/6445794#6445794 — StoryTeller - Unslander Monica, Jan 10 '18 at 11:57
Possible duplicate of [Can a local variable's memory be accessed outside its scope?](https://stackoverflow.com/questions/6441218/can-a-local-variables-memory-be-accessed-outside-its-scope) — Caleth, Jan 10 '18 at 12:27

score 1 · Accepted Answer · answered Jan 10 '18 at 11:54

For whatever it's worth, it's unnecessary to cleanup freed memory. Once it's freed and re-acquired, the state of its content turns into "indeterminate". In other words, it may contain data from last run, but it's absolutely unnecessary. You can't rely on this.

If you're confused, it's recommended that you zero-initialize the buffer:

char buf[SIZE] = {};

You can take a look at this question.

score 1 · Answer 2 · answered Jan 10 '18 at 12:01

It is undefined behavior. C++ has no notion of a "stack", that is a platform-specific detail. Generally what happens when you free "stack space" is that the stack pointer (i.e, esp. on x86, the stack grows downwards) is simply incremented. However, that doesn't mean the stuff on the stack automatically goes away. You cannot rely on undefined behavior because the standard says nothing about what will happen, so anything is a "valid" result.

JFMR · Answer 3 · 2018-01-10T12:20:46.723

I cant seem to comprehend why the buf variable in the read_file()function is not being cleared on consecutive call to evaluate().

Forcing always to clear the memory whether at allocation or release may incur a performance overhead. You are however free to do so when initializating or freeing (i.e.: before the control flows leaves the enclosing block where buf is declared) the memory.

Take into account that N successive calls to evaluate() like in the following code:

int main(){
   evaluate(); // first call  
   evaluate(); // second call

   ...

   evaluate(); // N call
   return 0;
}

would imply to clear that memory N times (think of the overhead).

Note that even though all the calls to evaluate() above will be using the same memory space on the stack, reading the memory prior to initialization results in undefined behavior. This way the standard imposes no requeriments on clearing data that has automatic storage duration.

score 0 · Answer 4 · answered Jan 10 '18 at 12:35

First of all, there is design issue in your class. Stack variables valid only in functions they declared. Because stack pointers probably valid, they must not be used for checking. Use allocated buffers (new, malloc(),HeapAlloc() or other function every time you read

void evaluate(){
   char *buf = new char[BUF_SIZE];
   read_file(buf);
   //evaluate the file->buffer contents
   delete [] buf;
}

And

void read_file(char *buf){
   int numread = pread(file->fd, buf, BUF_SIZE, file->curpos);
   // other logic follows
   file->buffer += buf;
}

This will help you with you question, but there will be next issue in file->buffer += buf;. There should think about other way to copy arrays.

Stack array variable cleanup

4 Answers4