What happens exactly when you pass by value pointer that is already allocated?

Question

What happens here in terms of allocation ? is it faulty situation to use pointers like this?

void f(int p[])
{ 
  p = (int*)malloc(sizeof(int));
  *p = 0;
}

int main()
{
  int *q = 0;
  q = (int*)malloc(sizeof(int));
  *q = 1;
  f(q);
  return 0;
}

Answer 1

The short answer is that p and q are independent variables. So first p will be assigned the same value as q and then p gets a new value due to the malloc . q is not changed by the function call. However, there is a memory leak due to p (and q ) not being freed.

You can see this using a few prints.

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

void f(int p[]) 
{
    printf("--------------------\n");
    printf("p is now %p\n", (void*)p);
    printf("p points to the value %d\n", p[0]);
    p = (int*)malloc(sizeof(int)); 
    *p = 0; 
    printf("--------------------\n");
    printf("p is now %p\n", (void*)p);
    printf("p points to the value %d\n", p[0]);
    printf("--------------------\n");
}

int main(){
    int *q = 0;
    q = (int*)malloc(sizeof(int));
    *q = 1;
    printf("q is now %p\n", (void*)q);
    printf("q points to the value %d\n", q[0]);
    f(q);
    printf("q is now %p\n", (void*)q);
    printf("q points to the value %d\n", q[0]);
    return 0;
}

The output (with a few comments to explain):

q is now 0x1912010        // In main q is initialized
q points to the value 1   // In main the location q points to is initialized
--------------------
p is now 0x1912010        // In function p first has the same value as q
p points to the value 1   // so it also points to the same as q
--------------------
p is now 0x1913040        // In function p gets a new value due to malloc
p points to the value 0   // and the pointed to memory gets a new value
--------------------
q is now 0x1912010        // Back in main q is the same as before the function call
q points to the value 1   // and the pointed to memory is unchanged as well

Answer 2

What I guess your question is about, it's the assignment

p = malloc(...)

in the function f .

That's a fully valid assignment, and works like any other assignment.

---

Consider this code:

void f(int p)
{
    p = 0;
}

int main(void)
{
    int q;
    q = 1;
    f(q);
}

In the function f there's a reassignment of the variable p , just like in your shown code. It's really just the same as for your code. It doesn't matter if p is a plain int variable, or a pointer variable. You can still reassign it as much as you want.

The thing to note is that arguments in C are passed by value . That means the value of the argument is copied into the functions argument variable ( p in your case and in my example). Modifying the copy (ie p ) will of course not modify the original. All modifications that the function f does will be lost once it returns.

So in my example, if you print the value of q after the call f(q) , then it would show that q is equal to 1 .

Answer 3

whenever you ask for allocation on heap using malloc for example- you have to free it, if you don't you get a memory leak- so for 2 mallocs here you must use 2 frees.

And you need to keep in mind that when you send q to the function you send it BY VALUE so if you check *q in main it will still stay 1.

if you want to change the value q is pointing to in the function you can send f(int **).

in your example a way to go if you want to change a where a pointer is pointing and to avoid memory leak is:

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

void f(int** p)
{
    free(*p); /*first free the initial main allocated memory on heap */
    *p = malloc(sizeof(int)); /*now the pointer is pointing to the new allocation */
    if(NULL == *p)
    {
       return;
    }
    **p = 0;
}

int main(){
    int *q = NULL;
    q = malloc(sizeof(int)); /*ask for memory allocation */
    if(NULL != q)
    {
       *q = 1;
       f(&q); 
       printf("%d\n", *q); /*now pointer is pointing to the allocationasked for by f */
       free(q); /*free the allocated place on heap */
     }
    return 0;
   }