Address of a pointer is equal to a pointer to pointer? - c

Question

I'm trying to understand how the pointers in this piece of code works:
void allocateArray( int **arr, size_t size, int value )
{
*arr = malloc( size * sizeof( int ));
if ( *arr != NULL )
for ( size_t i = 0; i < size; ++i )
*( *arr + i ) = value;
}
int main( void )
{
int *vector = NULL;
allocateArray(&vector,5,45);
free( vector );
return 0;
}
If I declared a pointer to an int ( *vector ), how passing its address makes it a pointer to a pointer to int ( **arr )? I mean, how does it work, now that vector's address in the memory will be overwritten!

Answer 1

C passes function parameters by value. So, to allow a function to modify a variable provided by the caller, a pointer to it must be passed. And the function must dereference the pointer to make the modification.
void foo_1 (int a) {
a += 1; /* caller will not see any change to a */
}
void foo_2 (int *ap) {
*ap += 1; /* caller will see value has changed */
}
int a = 0;
foo_1(a); /* a is still 0 after return */
foo_2(&a); /* a becomes 1 after return */
The & operator results in a value that represents the address to the object it is applied to, and the resulting type is "pointer to (type of the object)". In the above example, the result of &a is "pointer to int".
Nothing is fundamentally different if the variable is a pointer type.
void foo_1 (int *a) {
a = malloc(sizeof(int)); /* caller will not see any change to a */
}
void foo_2 (int **ap) {
*ap = malloc(sizeof(int)); /* caller will see value has changed */
}
int *a = 0;
foo_1(a); /* a is still 0 after return */
foo_2(&a); /* a becomes initialized to memory allocated by malloc */
In the above example, since a is a pointer to int, type of &a is "pointer to pointer to int".
A pointer is a term that is used to refer to the address of an object. The address of an object is a value that represents where the object resides in memory. Knowing that address means the object can be read and modified. A pointer variable is a variable that can store the address of an object.
Normally, the name of a variable is used to represent the object. By object, I just mean the memory used by the variable, and its semantic representation, aka, its type (often, the terms variable and object are used interchangeably, but to me, the difference is that a variable has a name). Reading and modifying the object is done through the name. One way to obtain a pointer to an object is to apply the unary & operator to the name of a variable. A pointer variable holding that address is thus a pointer to that object. And now, that same object can be read and modified via the pointer by dereferencing the pointer, using the unary * operator.
int a = 0;
int *ap = &a;
a += 1; /* a now has the value 1 */
*ap += 1; /* a now has the value 2 */
A dynamically created object, i.e. through malloc(), does not have a name. But, malloc() returns a pointer through which the object can be read and modified.
int *ap = 0; /* ap initialized to NULL */
ap = malloc(sizeof(int)); /* ap points to dynamically allocated int */
*ap = 0; /* int pointed to by ap now holds value 0 */
*ap += 1; /* int pointed to by ap now holds value 1 */
Your allocateArray() function combines both of these uses of a pointer into a single function.
int *vector = NULL; /* vector is pointer to int variable initialized to NULL */
allocateArray(&vector,5,45); /* the address of vector is passed to allocateArray */
Since the address of vector is passed to allocateArray(), that function now has the means to modify the object named vector by derferencing the pointer value it received. The pointer value is received in the arr argument:
void allocateArray( int **arr, size_t size, int value )
And, by dereferencing arr, it is updating the vector object with the value returned by malloc():
*arr = malloc( size * sizeof( int ));
Perhaps the function would have been more clear if the allocation, initialization of the memory, and then the update of the vector variable happened in multiple steps.
void allocateArray( int **arr, size_t size, int value )
{
int *vec = malloc( size * sizeof( int )); /* vec points to size contiguous int */
if ( vec != NULL )
for ( size_t i = 0; i < size; ++i )
vec[i] = value; /* vec[i] set to value */
*arr = vec; /* return vec into first parameter */
}

Answer 2

Some background:
Parameters in C are always passed by value. For example, consider the code
void some_func(int i) { i = i + 2; printf("i = %d\n", i); }
void main_func() {
int n = 5;
some_func(n);
printf("n = %d\n", n);
}
Output:
i = 7
n = 5
The main function passes the value 5 to some_func, which changes its own local copy in i but cannot change n in the calling function.
Now, suppose you want to write a function that does change the caller's value. You can do this by passing the address of the variable you want to change:
void new_func(int *i) { *i = *i + 2; printf("*i = %d\n", *i); }
void main_func() {
int n = 5;
some_func(&n);
printf(" n = %d\n", n);
}
Output:
*i = 7
n = 7
The "trick" is that new_func doesn't change the value of its parameter; it changes some other value -- the variable its parameter points to. So the rule is:
If you want a function to alter a variable, you pass the address of that variable.
In other words, if you want a function to change foo, you pass a pointer to foo.
Application to your code:
The main function declared a pointer, vector, that has no memory allocated to it. Its value is NULL. It calls allocateArray() to allocate memory and assign it to vector. But that means it must change the value of vector from NULL to the address of the newly-allocated memory. Following the same rule as above, in order to change vector, you need to pass its address to allocateArray(). And since vector is of type pointer-to-int, its address is of type pointer-to-pointer-to-int.
To be clear: you haven't changed the type of vector; you've simply passed its address. So within allocateArray(), arr is of type int **, and *arr is of type int *. Syntactically, you use *arr exactly as you would use vector.

Answer 3

So vector is a pointer to an int, so the address of vector is a pointer to a pointer to an int(&vector is equivalent to int **). vector = *arr, not &vector = *arr. Therefore vector is gets the address that the call to malloc returns, not the address of vector. I think the confusion is between the address of vector and the address that vector points to.

Answer 4

Inside the function main(), vector is a single variable on the stack (probably 4 bytes). The address of the first of those 4 bytes is &vector. When you call allocateArray(), you allocate a chunk of memory on the heap. The address of those bytes has to be stored somewhere. The function stores that 4-byte address at the memory address passed to it, i.e., the bytes allocated on the stack.
So when we return to main(), the variable vector now points to the start of the allocated block. Because it is declared as a pointer to int, that memory will be accessed as an array of ints.
Memory addresses are just numbers like any other number. The "type" you assign to it in C just tells the compiler what you plan to do with the memory at that address. Declaring vector as an int * simply tells the compiler to fetch an int from memory when it sees *vector. The memory used to store the value of the variable itself is just the stack, exactly as if it had been a regular int, and that memory has nothing to do with the memory it points to.
We need to take the address of the stack variable because otherwise allocateArray() would have no way to affect the value of the variable vector, which is not defined in its scope, so we just have to tell it where to look.
Probably a better way to implement this is to remove that first argument to allocateArray() and have it return the address of the allocated block. Then we can just assign vector to that return value in main() where it's in scope.

Answer 5

int main( void )
{
int *vector = NULL;
allocateArray(&vector,5,45);
free( vector );
return 0;
}
As you see in the main function, when the statement allocateArray(&vector,5,45); executed,
the memory address of a 5-element array will be passed to the vector variable; However, if you use allocateArray(vector,5,45);(assume that was corrected modified), then the memory address would not passed to the vector variable, because the function allocateArray(vector, 5, 45) now just passed a value of vector into the function.