Better way to allocate memory for flexibility and handle

Question

There's different coding style with different programmers. Colleagues and I are working on image data processing and we have 3 different ways.

Colleague1:

int IMAGE_WIDTH=1280;
int IMAGE_HEIGHT=800;

char* colleague1_way() //just allocate when he wants
{
char* mem = malloc(IMAGE_WIDTH*IMAGE_HEIGHT*2);
return mem;
}

int main(void)
{ 
    char* data;

    data=colleague1_way();
    function1(data); //pass by pointer
    function2(data); //pass by pointer
    function3(data); //pass by pointer

    free(data);
}

Colleague2:

int IMAGE_WIDTH=1280;
int IMAGE_HEIGHT=800;
char* data;    //set it as global memory

void colleague2_way()
{
data = malloc(IMAGE_WIDTH*IMAGE_HEIGHT*2);
}

int main(void)
{
    colleague2_way();

    function1(); //void input, proceed data inside function
    function2(); //void input, proceed data inside function
    function3(); //void input, proceed data inside function

    free(data);        
}

Me:

int IMAGE_WIDTH=1280;
int IMAGE_HEIGHT=800;

int main(void)
{
    char* data = malloc(IMAGE_WIDTH*IMAGE_HEIGHT*2);

    function1(data); //pass by reference 
    function2(data); //pass by reference
    function3(data); //pass by reference

    free(data);        
}

My idea is

1. I could see the allocated memory clearly, and free it at the end of main().
2. function1~3 might be in another cpp file, so it's easy to handle.

Anyone could give me a comment and is there any better way? Also, if it's in C++, any good ways?

Answer 1

I dont know the specifics of why you want heap memory but stack is faster. Your sample code makes your program seem small so i would do something like:

#define IMAGE_WIDTH 1280
#define IMAGE_HEIGHT 800
#define PIXEL_DEPTH 2

int main(void)
{
    char data[IMAGE_WIDTH][IMAGE_HEIGHT][PIXEL_DEPTH] = {0};

    function1(data); //pass by reference 
    function2(data); //pass by reference
    function3(data); //pass by reference

}

This is like your solution but you dont have to worry about freeing memory and you get faster writes. Like you said different programmers have different solutions, thats just my two cents.

Answer 2

First lets talk about "Colleague2" way: char pointer data declared globally

You should avoid declaring variables globally until it is really needed. Here, I don't see any reason of declaring data pointer globally. Since it is visible to other functions it's scope is increased and can be accidentally modified by other part of code which is not desirable.

"Colleague1" and "Me" way:
In these both ways, one good thing is the scope of data pointer is limited. But in the "Colleague1" way the memory allocation operation is part of another function, which is actually good because you can do the memory allocation error handling in one place (which is missing in all the 3 ways). Consider a case where you need to allocate same size of memory in some other part of the code then you just need to call this function instead of again doing malloc. If you are sure that you will not need to allocate the same size of memory again then in that case "Me" way is also okay. So, out of these two ways follow whichever way is appropriate but make sure to do the required error handling.