passing pointers in nested functions

Since function1 doesn't see the changes either, your question makes no sense.

Code:

Code:

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

void function2(int *ptr) {
    ptr = malloc(5 * sizeof(int));
    printf("function2 just happened to ptr %p.\n", ptr);
}

void function1(int *ptr) {
    printf("ptr is %p.\n", ptr);
    function2(ptr);
    printf("ptr is now %p.\n", ptr);
}

int main(void) {
    int *bob = NULL;
    printf("bob initialized to %p.\n", bob);
    function1(bob);
    printf("bob is finally %p.\n", bob);
    return 0;
}

Output:

Code:

$ ./temp
bob initialized to 0x0.
ptr is 0x0.
function2 just happened to ptr 0x100160.
ptr is now 0x0.
bob is finally 0x0.

Originally Posted by tabstop

Since function1 doesn't see the changes either, your question makes no sense.

Code:

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

struct _node {
        int X;
        struct _node *next;
};
typedef struct _node node;

//struct _node *testfunc2 ...
void testfunc2 (struct _node *ptr) {
        node *here=malloc(sizeof(*here));
        here->X=12;
        ptr=here;
        if (ptr!=NULL) puts("arghh.");
}    

void testfunc (struct _node *ptr) {
        testfunc2(ptr);
        //ptr=testfuction2(ptr);
        if (ptr!=NULL) puts("yes");
}

int main () {
        struct _node *ptr=NULL;
        testfunc(ptr);
        if (ptr!=NULL) puts("YES");
        return 0;
}

Output:

Code:

arghh.

I think I must have been doing that thing in red there.

I would just be aware that you are neither freeing your allocated memory, nor saving the pointer itself, so it's two memory leaks, so to speak.
Since the main function needs that memory, you need to pass a T** to get that value in that pointer back to main, and thus free it properly.

Originally Posted by MK27

I noticed today that a pointer declared in main, when passed to function that passes to a function, will not change regardless of what these functions do -- altho the changes in the second function affect the first function (but not main) whereas one passed to a function that changes it will. Am I off my rocker? Why is this?

A simpler example:

Code:

#include <stdio.h>

void foo(int x, int *p)
{
    printf("Before assigning to p in foo: &#37;p\n", (void*)p);
    p = &x;
    printf("After assigning to p in foo: %p\n", (void*)p);
}

int main()
{
    int x = 123;
    int *p = 0;
    printf("Before calling foo in main: %p\n", (void*)p);
    foo(x, p);
    printf("After calling foo in main: %p\n", (void*)p);
    return 0;
}

The reason is that pointers are passed by value, so if you change the local pointer in the function, the change is not reflected in the caller. You have to pass a pointer to a pointer instead. Of course, if you change what the pointer points to, then the change is reflected in the caller, since the caller's pointer points to the same object.

Yes, and like int, if you want a pointer to be changed inside a function, you need to pass a pointer to the pointer.

--
Mats

That's because the value of the pointer, i.e. the address it holds is copied by value. Remember that everything in C is copied by value and pointers just allow you to pass around an address, which can then be dereferenced to get to the real value.
What happens is that in your function1, ptr is a variable, which you pass to function2, where it is assigned. When function2 returns, ptr holds the address, but because ptr is a copy of the original variable (also unfortunately named ptr) that was passed to function1, it will have no effect on the ptr in main.

QuantumPete
wtf? How can my reply come before the original post???

I noticed today that a pointer declared in main, when passed to function that passes to a function, will not change regardless of what these functions do -- altho the changes in the second function affect the first function (but not main) whereas one passed to a function that changes it will. Am I off my rocker? Why is this?

Code:

int main() {
     struct _node *ptr=NULL;
     function1(ptr);
     //ptr still NULL
}
function1(struct _node *ptr){
     function2(ptr);
     //ptr reflects malloc & assignment
}
function2(struct _node *ptr{ 
     malloc and assign ptr.
}