malloc为结构转换内存

Question

What is the right way to malloc memory ? And what is the difference between them ?

void parse_cookies(const char *cookie, cookie_bank **my_cookie, int *cookies_num)
{
   *my_cookie = malloc(sizeof(cookie_bank) * 1);
   *my_cookie = (cookie_bank *)malloc(sizeof(cookie_bank) * 1);
   my_cookie = (cookie_bank **)malloc(sizeof(cookie_bank) * 1); 
   ///
}

I'm trying to malloc array of cookie_bank structs function.

Answer 1

I'm assuming that you want the function to allocate memory for an array and passing the result via a pointer parameter. So, you want to write T * x = malloc(...) , and assign the result to a pointer argument, *y = x :

cookie_bank * myarray;
parse_cookies(..., &myarray, ...);
/* now have myarray[0], myarray[1], ... */

So the correct invocation should be, all rolled into one line,

parse_cookies(..., cookie_bank ** y, ...)
{
  *y = malloc(sizeof(cookie_bank) * NUMBER_OF_ELEMENTS);
}

Answer 2

Your second example is the most correct. You don't need the *1 obviously.

*my_cookie = (cookie_bank *)malloc(sizeof(cookie_bank) * 1);

Your first example is also correct, although some compilers/flags will cause a complaint about the implicit cast from void*:

*my_cookie = malloc(sizeof(cookie_bank) * 1);

It you want to allocate more than one entry you'd generally use calloc() because it zeros the memory too:

*my_cookie = (cookie_bank*)calloc(sizeof(cookie_bank), 1);

your third example is just wrong:

my_cookie = (cookie_bank **)malloc(sizeof(cookie_bank) * 1); 

This will overwrite the local my_cookie pointer, and the memory will be lost on function return.

Answer 3

I just would like to recommend you to read some C textbook. It seems to me that you do not have clear understanding on how pointers work in C language.

Anyway, here is some example to allocate memory with malloc.

#include <stdlib.h>

void parse_cookies(const char *cookie, cookie_bank **my_cookie, int *cookies_num)
{
    if (cookies_num == NULL || *cookies_num == 0) {
        return;
    }
    if (my_cookie == NULL) {
        my_cookie = (cookie_bank**)malloc(sizeof(cookie_bank*) * *cookies_num);
    }
    for (int i = 0; i < *cookies_num; i++) {
        *my_cookie = (cookie_bank*)malloc(sizeof(cookie_bank));
        my_cookie++;
    }
}

Of course, this example does not cover any error handling. Basically, my_cookie is pointer to pointer which means my_cookie is just pointer to point memory location where it holds array of pointers. The first malloc allocate the memory using size of pointer and requested number of cookie structure. Then second malloc actually allocate memory for each structure.

The problem of this function is that it can easily cause memory leak unless using this very carefully.

Anyway, it is important to understand how C pointer works.