Pointer to reference assignment - c++

Question

I'm a bit confused about the assignment in C++:
Q1: Why this works:
int *z = &x;(1)
while this, of course, doesn't work:
*z = &x;(2)
Q2: Same kind of question for function:
funct(int *z)
And you call it:
int x;
func(&x);
does it mean *z=&x?
I know I passed the address in the above case (z=&x). But should the two terms on two sides of the assignment should be exactly the same?

Answer 1

Assuming x is declared as an int
int x;
Then your first line
int *z = &x;
Says declare z to be of type pointer to int. Initialize it with a pointer to the int x. All good. It type checks fine. z is a pointer to an int, and so is &x.
But now
*z = &x;
fails because z is a pointer to an int, so *z is an int! You can't assign &x, which is a pointer to an int, to an int. That is a type mismatch.
Now in your function call question
void func(int *z) {...}
Your call
func(&x);
is fine. It passes &x, a pointer to an int, by value to the parameter z, which is itself a pointer to an int. Inside of func you do get the effect of z = &x. Parameter passing by value is very much like assignment.
ADDENDUM
The reason you will see a value such as &x passed to a parameter declared with a pointer type such as int *z is that it allows the caller's x to be modified through the parameter z. In other words:
void func(int *z) {
*z = *z + 1;
}
if called like this
int main() {
int x = 10;
func(&x);
cout << x << '\n';
}
will output 11. Passing &x to z means both that z == &x and *z == x, or even stronger, that *z and x are now aliases of the exact same entity in memory! Any change made to *z affects x and vice versa; the two expressions refer to the same memory location.
In pictures:
+-------+ +-------+
z | | | | *z
| +---+----------------------------->| |
&x | | | | x
+-------+ +-------+

Answer 2

int *z = &x;(1)
delares z to be of type "int*" The "* is a part of the type, and is not part of a pointer dereference -- so you are assigning "z = &x" and NOT "*z=&x"
That should alos explain why 2 does not work -- the correct statement for (2) would be
z = &x;

Answer 3

It is bad rule to write
int *z;
better write
int* z;
this leads to such confusions.
Here z is variable and int* is a type, similar to float and int types. This type is called a pointer. It stores an address in memory where you variable (including pointers) can be stored.
In C++ you assign one value of a type to another. So here every there you assign z = &x. This works because &x gives you a pointer to x. That does mean an address in memory where your int x variable lays.
Also you should not confuse declaration of variable:
int* z;
int x;
float& f; // reference variable
and expression:
*z;
&f;
In upper case * and & are parts of declaration, are parts of type like "short" is a part of type "short int". In lower case they are parts of expressions - operators like "+" and "-". These are completely different things, though you use same symbols for them.

Answer 4

When you write, *z = &x;, you are de-referencing the pointer z, meaning that you are trying to assign the pointee (an int) to the address of x
To assign the pointer (and not the pointee), please write z = &x;

Answer 5

When you write type* z or type *z the type specifier takes precedence and the '*' is a modifier of the type. Thus both int* z and int *z mean "declare z, such that z is a pointer to type int".
int* z = &i; // pointer-to-int z = the address of i
int *z; // z is a pointer-to-int
z = &i; // pointer-to-int z = the address of i
int *z; // z is a pointer-to-int
*z = &i; // take the address of i and store it in integer who's address z contains