Thread: Here we go again: when to use Malloc and when not?

I do not have a good theoretical grasp of when to use malloc(). I know what it does, but I am too new to C to really dig it. I am quite aware that a considerable number of eyes are starting to glaze over now out of sheer boredom, but I searched for it, found a lot, but nowhere a good and concise overview.

I have found one clear use for malloc(), if I want persistent results from a function that do not get cleared when I exit the function, I use malloc. The rest is kind of vague with ominous talks about memory management, safe pieces of memory and what all, conceptual clarity is lacking. So, to be clear, my question is when one should use malloc.

The example I am using is a very simple concatenation.

Malloc version (not mine):

Code:

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

#define BEGIN "@@"
#define END "CCC"

int main (void)
  {  
    char *result = malloc(100 * sizeof(char));  // create some string space

    strcpy(result, BEGIN);              
    // result holds @@
    strcat(result, "this is a message");
    //result holds @@this is a message
    strcat(result, END);   
    // result holds @@this is a messageCCC

    printf("%s\n\n", result);
    free(result); 
    return 0; }

The version without malloc:

Code:

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

#define BEGIN "@@"
#define END "CCC"

int main (void)
  {  
   char *result;

    strcat(result, BEGIN);    
    // result holds @@
    strcat(result, "this is a message");     
    //  result holds @@this is a message
    strcat(result, END);   
    // result holds @@this is a messageCCC

    printf("%s\n\n", result);
    return 0; }

Both versions run well, but is this coincidence? What risks to I run if I work without malloc in this case, is this good programming or a don't?

What you really need to do is read about the differences between static and dynamic (malloc & friends) memory allocation. This is a subject that has been debated so many times that I just won't believe you haven't found anything on it so far. You don't even care that much about C in particular right now, but rather about understanding the broader subject.

Originally Posted by django

Both versions run well, but is this coincidence?

Yes. The first version is fine, other than a missing check that malloc does not return a null pointer. You end up with a string of length 22, which means that you need a char array of at least size 23 to contain it. Since the pointer points to the first character of a dynamic char array of size 100, you're safe.

The second example results in undefined behaviour. result was not initialised, so it contains "garbage", and you will essentially be overwriting memory that was not allocated to you.

Code:

Note that in this case it would be easier to do without malloc by using a fixed size array, e.g.,
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BEGIN "@@"
#define END "CCC"

int main(void)
{
    char result[100];

    strcat(result, BEGIN);
    // result holds @@
    strcat(result, "this is a message");
    //  result holds @@this is a message
    strcat(result, END);
    // result holds @@this is a messageCCC

    printf("%s\n\n", result);
    return 0;
}

I would be more likely to use malloc if there is need for a dynamic array, or if the size is large.

Originally Posted by django

However, malloc does not initialize either, for that you would have to use calloc.

No, malloc initialises your pointer. It does not initialise the contents of the allocated memory, but that is fine since you are using strcpy immediately.

Originally Posted by django

Now suppose that I would use as a first statement not strcat, but strcpy, would this initialize the results pointer in a correct way? And, having done this and thus eliminated the fault of using an uninitialized pointer, would it still be fundamentally incorrect code (although it may by coincidence display the right result)?

Oh, right. I did not notice that you were using strcat before strcpy in your second example. An uninitialised pointer is an uninitialised pointer, regardless of what you try to do to what it points to.

Originally Posted by django

So basically, there are two ways to initialize a pointer:
(1) dynamically assign memory to it
(2) statically assign memory to it by doing something of the sort

I would not say "dynamically assign memory" or "statically assign memory". Rather, I would consider the two ways to be:

• Assign the address of an object (or function, in the case of a function pointer) to the pointer (or as a special case, the address one past that of the last element of an array).
• Assign a null pointer constant, or the value of a null pointer, to the pointer.

Whether the address was obtained via malloc or by taking the address of a local variable does not matter when we are just talking about providing a pointer with a value.

Originally Posted by django

Both versions run well, but is this coincidence? What risks to I run if I work without malloc in this case, is this good programming or a don't?

The second version works by pure dumb luck and nothing better... Ask yourself: "Where does result point?" ... pray it's not pointing at your program's stack or some necessary system control block when you start dumping text into it...

You cannot ever use memory you don't own... It's like carrying water without a bucket... malloc() and free() lease and return memory. There are no shortcuts.

Here is another good read on pointers that might help explain some of these things: Prelude's Pointer Tutorial.