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

Question

The code confused me.

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

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;
}

score 7 · Answer 1 · answered Feb 28 '11 at 14:08

7

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;
}

answered Feb 28 '11 at 14:08

Ken Keenan

9,818
5
32
49

2

Or better, `int *create_int(void) { return malloc(sizeof(int)); }`, then just `int *p = create_int();`. – Steve Jessop Feb 28 '11 at 14:10
4

@HiMing: because `p` in your `create_int` function is a completely different variable from `p` in your `main` function. It just has the same value initially, because you passed the value of the one in main as the parameter. Changing the value of `p` in `create_int` has no effect on the value of `p` in `main`, which remains a null pointer. – Steve Jessop Feb 28 '11 at 14:11

score 2 · Answer 2 · answered Feb 28 '11 at 14:08

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;
}

score 2 · Accepted Answer · answered Feb 28 '11 at 14:10

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);

score 2 · Answer 4 · edited May 23 '17 at 12:19

2

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?).

edited May 23 '17 at 12:19

Community

1
1

answered Feb 28 '11 at 14:11

unwind

391,730
64
469
606

Also, in C you should never cast the return value of malloc(). But I always see cast. Why not cast? – HiMing Feb 28 '11 at 14:24
@HiMing: I added the relevant link, please refer to that question for details. – unwind Feb 28 '11 at 17:17
`sizeof(int *)` should be `sizeof(int)` – aschepler Feb 28 '11 at 17:37

score 1 · Answer 5 · answered Feb 28 '11 at 14:09

1

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;
}

answered Feb 28 '11 at 14:09

Vite Falcon

6,575
3
30
48

score 0 · Answer 6 · answered Feb 28 '11 at 14:13

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;
}

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

6 Answers6