Why I've allocated a pointer memory in a function, but it's also NULL?

The code confused me.

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

void create_int(int *p)
{
    p = (int *) malloc(sizeof(i开发者_StackOverflownt));
}

int main()
{
    int *p = NULL;

    create_int(p);

    assert(p != NULL);  /* failed. why? I've allocated memory for it. */

    return 0;
}

You are not passing the pointer value back from the function. Try:

void create_int(int **p) {
     *p = (int *) malloc(sizeof(int)); 
}  

int main() {
     int *p = NULL;      
     create_int(&p);
     assert(p != NULL);  /* failed. why? I've allocated memory for it. */
     return 0;
} 

The variable p in the function create_int is a copy of the variable p in main. So any changes made to p in the called function does not get reflected in main.

To make the change get reflected in main you need to either:

Return the changed value:

int* create_int(int *p) {
    p = malloc(sizeof(int));
    // err checking
    return p:
}
...
// in main:
p = create_int(p);

Or pass the address of p as:

void create_int(int **p) {
    *p = malloc(sizeof(int));
    // err checking
}
...
// in main:
create_int(&p);

You need a pointer to a pointer like this:

void create_int(int **p)
{
    *p = (int *) malloc(sizeof(int));
}

int main()
{
    int *p = NULL;

    create_int(&p);

    assert(p != NULL);  /* failed. why? I've allocated memory for it. */

    return 0;
}

As folks have pointed out, it's failing since you're not actually changing the pointer that the caller has.

A different way to think about the code might be to notice that it's basically wrapping malloc(), i.e. it's doing a memory allocation but with intelligence added. In that case, why not make it have the same prototype (=call signature) as malloc()? That makes it clearer in the caller's context what's going on, and easier to use:

int * create_int(void)
{
  return malloc(sizeof (int));
}

int main(void)
{
  int *p = create_int();
  assert(p != NULL);
  return 0;
}

Also, in C you should never cast the return value of malloc() (see Do I cast the result of malloc?).

You need to send a pointer to a pointer to be able to assign a memory to it via a function

void create_int(int **p)
{
   *p = (int*)malloc(sizeof_int));
}

int main()
{
    int* p = NULL;
    create_int(&p);
    assert(p != NULL);
    return 0;
}

Your code contains two pointers: one in the create_int function and another one in main. When you call create_int, a copy of the pointer in main is made and used, then eliminated when the create_int function returns.

So, any changes you did to the copy within create_int remain there and are not propagated back to main.

The only way to propagate changes between functions in C (aside from, obviously, returning new values) is to pass a pointer to the changed values. This way, while the pointer being passed will be copied, the value that it points to will be the same, so changes will apply.

Since you're trying to change a pointer, you need a pointer-to-pointer.

void create_int(int **pp)
{
    // this changes the pointer that `p` points to.
    *pp = (int *) malloc(sizeof(int)); 
}

int main()
{
    int *p = NULL;

    // this sends a pointer to the pointer p in main        
    create_int(&p); 

    assert(p != NULL);  

    return 0;
}