Dynamic memory access only works inside function

by

The reason for this bug is that the data used by the create_array function is a local variable that only exists inside that function. The assigned memory address obtained from malloc is only stored in this local variable and never returned to the caller.

Consider this simple example:

void func (int x)
{
  x = 1;
  printf("%d", x);
}

...
int a;
func(a);
printf("%d", a); // bad, undefined behavior - the program might crash or print garbage

Here, a copy of the variable a is stored locally inside the function, as the parameter x. This is known as pass-by-value.

When x is modified, only that local variable gets changed. The variable a in the caller remains unchanged, and since a is not initialized, it will contain “garbage” and cannot be reliably used.

Pointers are no exception to this pass-by-value rule. In your example, the pointer variable data is passed by value to the function. The data pointer inside the function is a local copy and the assigned address from malloc is never passed back to the caller.

So the pointer variable in the caller remains uninitialized and therefore the program crashes. In addition, the create_array function has also created a memory leak, since after that function execution, there is no longer any pointer in the program keeping track of that chunk of allocated memory.

There are two ways you can modify the function to work as expected. Either by returning a copy of the local variable back to the caller:

int* create_array (int size)
{
  int* data = malloc(sizeof(*data) * size);
  for(int i=0; i<size; i++)
  {
    data[i] = i;
  }

  print_array(data, size);

  return data;
}

int main (void)
{
  int* data;
  const int size = 5;

  data = create_array(size);
  print_array(data, size);
}

or by passing the address to the caller’s pointer variable and write directly to the caller variable:

void create_array (int** data, int size)
{
  int* tmp = malloc(sizeof(*tmp) * size);
  for(int i=0; i<size; i++)
  {
    tmp[i] = i;
  }

  *data = tmp;      
  print_array(*data, size);
}

int main (void)
{
  int* data;
  const int size = 5;

  create_array(&data, size);
  print_array(data, size);
}

Either form is fine.

More Related Contents:

  1. When and why to use malloc?
  2. Why, or when, do you need to dynamically allocate memory in C?
  3. Malloc function (dynamic memory allocation) resulting in an error when it is used globally
  4. Why this program is crashing?
  5. How can I get the size of an array from a pointer in C?
  6. Why is it safer to use sizeof(*pointer) in malloc
  7. Difference between static memory allocation and dynamic memory allocation
  8. What’s the point of malloc(0)?
  9. Overriding ‘malloc’ using the LD_PRELOAD mechanism
  10. Using malloc for allocation of multi-dimensional arrays with different row lengths
  11. Why is malloc not “using up” the memory on my computer?
  12. newbie questions about malloc and sizeof
  13. Why do we need to specify the column size when passing a 2D array as a parameter?
  14. Maximum memory which malloc can allocate
  15. Pointers as function arguments in C
  16. free char*: invalid next size (fast) [duplicate]
  17. How to use realloc in a function in C
  18. Are there any downsides to passing structs by value in C, rather than passing a pointer?
  19. Dynamically create an array of strings with malloc
  20. C Warning: Function returns address of local variable
  21. malloc(sizeof(int)) vs malloc(sizeof(int *)) vs (int *)malloc(sizeof(int))
  22. malloc implementation?
  23. dynamic allocating array of arrays in C
  24. Simple C implementation to track memory malloc/free?
  25. Using sizeof() on malloc’d memory [duplicate]
  26. Why do I get a warning every time I use malloc?
  27. An alternative for the deprecated __malloc_hook functionality of glibc
  28. Why does this intentionally incorrect use of strcpy not fail horribly?
  29. Why can’t I pass constant arrays as arguments?
  30. Minimizing the amount of malloc() calls improves performance?

Leave a Comment