Allocate memory in one function and use it in another function - c

Question

The following code seems to work. gcc 5.2.1 on linux didn't give any warning.
I am a newbie to C. I got this working by writing down what the & and * operators do at each line with English sentences and trial and error.
There are two things that I am not sure.
The initial value of p0 in line A is unpredictable. Yet, line E assigns a value to the address specified by the value of the variable p0 in main. Will this cause any problem? If so, how to fix that?
The code use so many *, like *** in line C. Can it use less * without getting warning from gcc?
Thank you.
#include <stdlib.h>
#include <stdio.h>
void* f(int*** ptr_p) //C
{
int** p = *(ptr_p); //D
*p = malloc(8); //E
*(*p) = 200; //F
(*p)[1] = 4; //G
}
int main(void)
{
int** p0; //A
f(&p0); //B
printf("%d, %d\n",*(*p0), (*p0)[1]);
free(*p0); //H
}
In case if you want to see the English sentences, here they are.
Warning: I am a newbie in C, and I don't know if they are all correct.
Line [A] int** p0;
The value of p0 is unpredictable.
Line [B] f(&p0);
&p0 is address of variable p0. f(&p0) means to call function f and assign &p0 to the 1st argument of the function.
Line [C] void* f(int*** ptr_p)
Line B assigns &p0 to ptr_p. This means the value of ptr_p is now equal to the address of variable p0 in the main function.
Line [D] int** p = *(ptr_p);
*(ptr_p) means the value at an address specified by the value of ptr_p, interpreted as an address. Value of ptr_p is address of variable p0 in the main function, as described in Line C. So, *(ptr_p) is value of variable p0 in the main function.
p = *(ptr_p); means assign value of p0 in the main function to value of p
Line [E] *(p) = malloc(8);
*(p) means value at an address specified by the value of p. Value of p is value of the p0 variable in main, as described in Line [D]. Then, *(p) means value of the address specified by the value of the p0 variable in main().
malloc(8) reserves 8 bytes in memory, and return the address of the first of the 8 bytes.
The whole line means to assign the address of the first of these 8 bytes as the value of the address specified by the p0 variable in main().
Line [F] *(*p) = 200;
Line [G] (*p)[1] = 4;
(p)[1] means *(p + 1)
(*p)[1] means *(*p + 1)

Answer 1

Yes, line E is a problem. Actually, you are already in trouble at line D, because you read the (undefined) value of p0. This is forbidden in C; it is part of the dreaded undefined behavior, which means that all bets are off and the compiler is legally allowed to output anything it wants: a binary that crashes, or prints "Hello world!", you name it.
You correctly saw that p0 should point to an int * buffer before you can write in that buffer. However, there is no need for this extra level of indirection. p0 can be an int *:
#include <stdlib.h>
#include <stdio.h>
void f(int** ptr_p) //C
{
*ptr_p = malloc(sizeof(int) * 2); //E
(*ptr_p)[0] = 200; //F
(*ptr_p)[1] = 4; //G
}
int main(void)
{
int* p0; //A
f(&p0); //B
printf("%d, %d\n", p0[0], p0[1]);
free(p0); //H
return 0;
}
One last thing: malloc could fail and return NULL; a robust program would check that.

Answer 2

You have more stars that you need: the fewer the better, so I have simplified your program.
#include <stdio.h>
#include <stdlib.h>
int *f(int size) // returns a pointer
{
int *p; // define a pointer
p = malloc(size); // allocate memory to it
if(p == NULL) { // check the result
exit(1); // emergency exit
}
*p = 200; // put a value at p[0];
p[1] = 4; // put a value at p[1];
return p; // return the pointer
}
int main(void)
{
int *p0; // pointer as yet has no value assigned
p0 = f(2 * sizeof *p0); // get memory for 2 ints and initialise it
printf("%d, %d\n", *p0, p0[1]); // show the two ints assigned
free(p0); // release the memory
return 0; // end of program
}
Program output:
200, 4
Apart from fewer stars, there are two main changes to your program
The function returns a pointer directly. Setting it via an argument requires one more star.
The amount of memory requested is for two elements of the data type, not "hard coded".
Also you are correct in thinking there is more than one way you can access an array based on a pointer.