Thread: Valid, Initialized Allocated Memory

What is a good way to ensure that allocated memory is initialized to a value? I know one can follow strict coding practices but I'm wondering how one can ensure allocated memory is properly initialized?

I tried the code below:

Code:

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

#define ARR_SIZE 5

typedef bool SET;

void check_allocation(void * ptr) {
  if (!ptr) {
    fputs("Allocation Failed!\n", stderr);
    exit(1);
  }
}

struct valid_memory {
  SET set;
  int * value; 
};

int main(int argc, char ** argv) {
  struct valid_memory vm[ARR_SIZE] = {
    {false, NULL}, 
    {false, NULL}, 
    {false, NULL}, 
    {false, NULL}, 
    {false, NULL}
    };

  for (size_t i = 0; i < ARR_SIZE; ++i) {
    if (vm[i].set) {
      fprintf(stdout, "set: %s, ptr: %p\n", vm[i].set ? "true" : "false", (void*)vm[i].value);
    }else {
      fprintf(stdout, "set: %s\n", vm[i].set ? "true" : "false");
    }
  }
  
  for (size_t i = 0; i < ARR_SIZE; ++i) {
    vm[i].value = malloc(sizeof(*vm[i].value));
    check_allocation(vm[i].value);
    *vm[i].value = i;
    vm[i].set = true;
  }

  for (size_t i = 0; i < ARR_SIZE; ++i) {
    if (vm[i].set) {
      fprintf(stdout, "set: %s, ptr: %p, value: %d\n", vm[i].set ? "true" : "false", (void*)vm[i].value, *vm[i].value);
    }else {
      fprintf(stdout, "set: %s\n", vm[i].set ? "true" : "false");
    }
  }

  for (size_t i = 0; i < ARR_SIZE; ++i) {
    free(vm[i].value);
    vm[i].value = NULL;
    vm[i].set = false;
  }

  for (size_t i = 0; i < ARR_SIZE; ++i) {
    if (vm[i].set) {
      fprintf(stdout, "--set: %s, ptr: %p, value: %d\n", vm[i].set ? "true" : "false", (void*)vm[i].value, *vm[i].value);
    }else {
      fprintf(stdout, "set: %s\n", vm[i].set ? "true" : "false");
    }
  }

  return 0;
}

Output from the above:

set: false
set: false
set: false
set: false
set: false
set: true, ptr: 0000000000BD13E0, value: 0
set: true, ptr: 0000000000BD1400, value: 1
set: true, ptr: 0000000000BD1420, value: 2
set: true, ptr: 0000000000BD1440, value: 3
set: true, ptr: 0000000000BD1460, value: 4
set: false
set: false
set: false
set: false
set: false

This problem seems simple at first but with some reflection it really exposes how dangerous C programming can get.

I am unsure what you are asking, and the code does not clarify it for me.

You appear to be concerned with the value of the pointer being null, which has nothing to do with allocated memory being initialized to a value, and everything to do with checking the return value of the memory allocator.

I would suggest that you create a "personalized" library and use that in lieu of the C standard library functions. Develop this over time, but each library call should be replaced with a (for example) "g_" version that is your own implementation. Mostly, these will call the underlying stdlib function, but will include whatever error checking or handling you like:

Code:

static inline
void *
g_malloc_impl(
    size_t size,
    const char * file,
    int line)
{
    void * result = malloc(size);
    if (is_null(result)) {
        // POLICY question:  What do you do on error?
        // This answer will likely change from desktop to embedded system...

        fatal_error(file, line, "malloc(%zu) failed", size);
    }

    return result;
}

#define g_malloc(size) (g_malloc_impl((size), __FILE__, __LINE__))

Most of the time your fatal error policy will be the same. The default, for one-off apps on the desktop, is probably just fprintf-and-exit. If you're in a more "nuanced" environment, such as writing plugins for a web browser or text editor, then you probably have an infrastructure already defined. If you're in an embedded environment, you'll definitely have such a thing defined (or you wouldn't be asking this question, yet!)...

Originally Posted by aghast

I am unsure what you are asking, and the code does not clarify it for me.

I basically want to check if allocated memory has a proper(initialized) value. I want to check if the allocated memory was initialized.

Originally Posted by G4143

I basically want to check if allocated memory has a proper(initialized) value. I want to check if the allocated memory was initialized.

malloc() does not initialize the memory to any specific value. The contents are whatever was in the memory when allocated.

calloc() will initialize the all the bytes allocated to nul bytes. (All bits set to zero)

If you want memory assigned, not initialized, to some specific value(s), you can use memset() or manually assign values in the allocated memory.

Please see the man pages for malloc(), and memset().