Thread: to malloc() or not to malloc()...

No.

The latter only lives for as long as the scope it is in. So if it's a global variable, it's going to live as long as the application. But if it's a local variable, it will disappear when the function returns. That may be a good thing or a bad thing, depending on what you want to do with the variable. If it's only used within the function, make it local.

Of course, malloc() will take a fair few cycles (as in hundreds or thousands) from the CPU to find the space for the memory, allocating the space on the stack involves a single add instruction - modern processors will do that in one clockcycle.

And of course, if you use malloc, you should use free to return the memory when you are finished.

--
Mats

Originally Posted by noops

Shouldn't it be malloc(sizeof(uint8_t) * 56)?

Yes, but if uint8_t is "unsigned char", we know that its size is 1.

--
Mats

Not really, because the memory for the latter is allocated on the stack, while the former is allocated on the heap. If you allocate something on the stack, it is available only within the function in which it is allocated. For example, this is very wrong:

Code:

#define SIZE_OF_BUF 56
uint8_t *right(void)
{
    uint8_t *buffer = malloc(SIZE_OF_BUF);
    int i = 0;
    for (i = 0; i < SIZE_OF_BUF; ++i)
        buffer[i] = i;
    return buffer;
}

uint8_t *wrong_wrong(void)
{
    uint8_t buffer[SIZE_OF_BUF];
    int i = 0;
    for (i = 0; i < sizeof(buffer); ++i)
        buffer[i] = i;
    return &buffer[0];
}

int main(void)
{
    uint8_t *output = wrong_wrong();
    // What's in the buffer variable is likely gone, because it was 
    // allocated on the stack and therefore went away once you
    // returned from the function.
    // output is now pointing somewhere it's not supposed to.
    printf("Yikes, accessing the output will likely crash!\n");
    
    output = right();
    printf("It will be fine to access output, however, "
             "you must de-allocate it when you're done\n");
    free(output);
 
    return 0;
}

Look here for a nice, *nix-specific explanation of memory management in C.