Thread: explanation code

yes, it could just be an int* if the code actually
did anything. There arent any functions being called
in your code, only function declarations, and those are
incomplete.

Code:

#include <...>
void fun(int *myInt);

int main(void)
{
     int j;
     fun(&j);
}

void fun(int *j)
{
     int a = 10;
     j = &a;
}

yea, there's no reason it can't be something like the above, all you are doing is
changing the integer value pointed at by j.

oh wait, I'm an idiot.
I think you need the double pointer because of memory allocation.
If you did what I just told you too, this is what i think the problem would
be:

Code:

#include <...>
void fun(int *myInt);  // declare your function

int main(void)
{
     int j;   // declare an integer and allocate space for it
     fun(&j);  // pass the address of that integer to your function
}

void fun(int *k)
{
     int a = 10;  // declare another integer and allocate space for it on the stack
     k = &a;       // point your pointer at that space. essentially *j = 10;
}  // except now the function ends and the space allocated for a goes away
   // leaving j pointing at something that may change unexpectedly

First: Implicit main = bad --> http://cpwiki.sourceforge.net/Implicit_main
Second, function prototypes should be global, in a header or at the beginning of the source file.
Third, many pointer questions are answered here: http://cpwiki.sourceforge.net/A_pointer_on_pointers

Your code is broken, too. You don't get warnings?
Basically a pointer to pointer is just a pointer to a variable that is of pointer type. If you want that pointer to retain a value when set inside a function, then you simply get a pointer to pointer. See link for more information.

One example might be:

Code:

int main(void)
{
     int* j;
     fun(&j);
}

void fun(int** j)
{
     *j = malloc(sizeof(int));
}

Now j in main will hold a pointer to an allocated buffer allocated using malloc that was allocated inside fun.