i cant get this difference - c

Question

#include<stdio.h>
typedef struct data
{
int a;
int b;
}dd;
dd *changed(dd **d);
dd changep(dd *d);
int main()
{
dd *d=(dd *)malloc(sizeof(*d));
d->a=5;
d->b=6;
changep(d);
printf("after entering into the functin %d\n",d->a);
changed(&d);
printf("%d\n",d->a);
}
dd changep(dd *d)
{
//d=(dd *)malloc(sizeof(*d));
d->a=14;
printf("%d\n",d->a);
}
dd *changed( dd **d)
{
*d=(dd *)malloc(sizeof(*d));
(*d)->a=3;
(*d)->b=4;
}
here changed and changep are changing the values in the structure why 2 use a double pointer then ??
and if i create new memory in changep then it is not changing its value why??

Answer 1

C uses pass by value in function parameter passing.
void changep(dd *pd) //notice the change
{
//d=malloc(sizeof(*d)); //do not cast
pd->a=14;
printf("%d\n",pd->a);
}
and it is called as
changep(d);
Here, pd is local to the function changep, i.e., a local copy of d. Any chnages made to pd will not be reflected to the caller function.
To make the changes relect to the caller [main()], you need a double pointer. That is why
void changed( dd ** pd)
{
if (pd)
{
if (! *pd)
*pd=malloc(sizeof(*d)); //do not cast
(*pd)->a=3;
(*pd)->b=4;
}
}
and the calling
changed(&d);
reflects the changes made to *pd to d in main().

Answer 2

this is difference of function using value parameters and function using reference parameters.
If you want to change a var pointed by a pointer by calling function, you must use a pointer as parameter. So if you want to change a pointer by calling function, you must use a pointer which point to that pointer!

Answer 3

Both of your functions change the values of the struct members. You confusion is over why single or double pointers? and when to use one vs the other? They are effectively the same, but there are a couple of subtle consideration. In both you are passing a pointer (a reference), so the function will receive an address as an argument, and can modify the value stored at that memory address such that the change is visible outside of the function in say main.
First, when passing a single pointer to a struct (or anything else), the intent is generally, not always, but generally to operate on that pointer and memory location such that the caller receives the new values without needing a return. In this general case, there is no general need to return anything, and the function can properly be of type void and return no value.
The second situation is where you need the function to be able to change the address for the data struct in some way, like when deleting a first or last node in a linked-list. In this situation, the function needs to have access to the address of the pointer (not just the memory address the pointer points to) in order to make the node changes.
Here, you generally think of passing the pointer as a double pointer so if a new list node takes its place, not only are the values pointed to by the pointer subject to change, but the address of the pointer itself may undergo a change. This is one of the few areas when passing a double pointer is required -- when you need to change the address of the pointer itself. Since you need to return this pointer to the caller, these functions are generally of the struct pointer type so that after the list address have all gone through their change, you can return the new address to the start of the list (or whatever) to the caller. So these type function are declared as struct name* to accommodate the requirement.
NOTE However, you can still operate on the values of the pointers provided to the function without providing a return, but if you do need to change the address of the struct provided, then the double pointer is required.
Your code acted appropriately with both, and for your double-pointer function, there was no need for a return. but the values in main reflected the new values:
#include <stdio.h>
#include <stdlib.h>
typedef struct data {
int a;
int b;
} dd;
dd *changed (dd ** d);
void changep (dd * d);
int main () {
dd *d = malloc (sizeof (*d));
d->a = 5;
d->b = 6;
changep (d);
printf ("after entering into the functin %d\n", d->a);
changed (&d);
printf ("%d\n", d->a);
return 0;
}
void changep (dd * d)
{
//d=(dd *)malloc(sizeof(*d));
d->a = 14;
printf ("%d\n", d->a);
}
dd *changed (dd ** d)
{
// *d = (dd *) malloc (sizeof (*d));
(*d)->a = 3;
(*d)->b = 4;
return *d;
}
output:
$./bin/spassvr
14
after entering into the functin 14
3