Programming

If one wants to get a start address of a array or a string or a block of memory via a function, there are at least two methods to achieve it:
(1) one is to pass a pointer-to-pointer parameter, like:

Code:

int my_malloc(int size, char **pmem)
{
      *pmem=(char *)malloc(size);
      if(*pmem==NULL) {
             return NOK;
      }
      return OK;
}
int main()
{
       char *my_pmem;
       if(my_malloc(64, &my_pmem)==OK){
        ...
       } else {
       ...
       }
}

(2)the other is to return a pointer, like:

Code:

void * my_malloc(int size)
{
       void * pmem;
       pmem=malloc(size);
       return pmem;
}
int main()
{
      char *my_pmem;
      my_pmem=(char *)my_malloc(64);
      if(my_pmem==NULL) {
           ...
      } else {
           ...
      }
}

Could anyone tell the difference(advantages and disadvantages )about those two methods ？

Thanks in advance !

Why are you using the function in this scenario? By using function calls you are creating the overhead of function call and temporaray object.

I just want to know the advantages and disadvantages of those two methods by this simple example... actually, in practice, especially in memory management application for a special or embedded system, it is necessary to implement our own function to malloc a block of memory. Then the case raises.

I prefer the second form because:

The actual difference is that the first example copies the address of your pmem pointer to the stack and the second example doesn't. The second example only works because you're using malloc() which allocates memory from the heap, otherwise you could have unexpected behavior because you would be returning a local variable (which is cleared upon function completion).

IMHO the second option would be faster because there's one less parameter to be copied to the stack and there's no desreferencing of the pointer's address to obtain the data. Anyway, you should feel no significant speed difference in any of the alternatives.

I can't see any effective difference aside from the extra complications of effectively returning two values in your first example. I'd tend to avoid that kind of redundancy in case my fumble fingers ever cause one to contradict the other.

Like everyone else I too prefer the second method one over the first as it is simpler, easier to understand and uses much less storage in the stack segment. Also I don't see the need for a function call just to malloc a chunk of memory. For an embedded system where resources are scarce you are better off mallocing that block of memory in main.