Thread: uninitialized value was created by a heap allocation, memcheck with valgrind

You do not need to pass the type as a parameter since it can be deduced by the destination pointer type. Hence, you could have written ALLOC as:

Code:

#define ALLOC(result, num_elements) do {\
    if (((result) = malloc(sizeof(*(result)) * (num_elements))) == NULL) {\
        fprintf(stderr, "malloc failed");\
        exit(EXIT_FAILURE);\
    }\
} while (0)

Anyway, I suggest that you compile and check a simplified program with Valgrind:

Code:

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

#define ALLOC(P, T, S) if (((P) = (T*)malloc(sizeof(T) * (S))) == NULL) {\
    fprintf(stderr, "malloc failed");\
    exit(1);\
}

typedef unsigned int Uint;

int main(void) {
    Uint *used;
    Uint a_num = 5;

    ALLOC(used, Uint, a_num);
    free(used);
    return 0;
}

What does Valgrind report?

Originally Posted by tinchi

What about my second post? Do I allocate correctly??

It looks okay.

Originally Posted by tinchi

I think I have noticed something, can it be that if I allocate an array, that I always have directly to set the entries to some standard value, so 0 for ints, because in my method sometimes they are set in an -if- part so maybe this is one problem?

No, this is not necessarily a problem, though providing a sensible initial value is a Good Thing. You probably have a bug such that you did not provide an initial value, and yet you used the object. Notice:

Code:

==19505== Use of uninitialised value of size 8
==19505== Uninitialised value was created by a heap allocation

malloc() doesn't initialise the memory it provides. valgrind will complain if any any path through your program is executed in which that memory is used without being initialised.

Following your code

Code:

int i;
int **my_array;
 
//First allocation: (see upper post for the definition of ALLOC)
ALLOC(my_array, int*, 2);
 
//now second dimension:
for(i =0; i < 2; i++){
 
ALLOC(my_array[i], int, 20); //so an array of 20 entries
}

the individual my_array[i][j] (i = 0-1, j = 0-19) are uninitialised. My guess is that some subsequent code accesses such values (e.g. reads their value, compares their value with something) before initialising them.

Originally Posted by tinchi

I will check where I use objects I forgot not initialise, strange that the code compiles if this is the case

Not strange at all.

Using uninitialised variables results in undefined behavior according to the standard. That means, among other things, that a compiler is not required to detect such problems, and is not required to do anything in particular (useful or otherwise) if it does.

Technically, there are particular cases (variable defined but uninitialised in one compilation unit, value of that variable accessed in another compilation unit) that a C compiler cannot necessarily even detect, let alone report a compilation error. The only way that could be eliminated would be to completely change C's compilation model - in particular, to eliminate separate compilation. That would make C compilers more expensive (more code needed for analysis that programmers often don't need) and - for large programs with many compilation units - would increase build times by several orders of magnitude.

You could also make use of some additional tools, such as static analysers. Such tools tend to be expensive but they do pick up problems that will not be detected by a stock-standard C compiler. Some C compilers do some forms of static analysis (which is why some compilers give warnings, if they are appropriately configured, about uninitialised variables). But C compilers are not required to do this and, even if they do, there are still problems they cannot detect.