memory locations of pointer, variable, and value in C?

What is &y? Is it the address in memory of the pointer variable y?

Yep. You can have pointers-to-pointers as well.

int x = 357;
int *y = &x;
int **z = &y;

What is the pointer variable y? Does it hold the address of the variable x?

Yes. Basically, it is an integer-ish type that (as its value) holds the address of 'x'.

What is &x? Is it the address in memory of the variable x itself or is it the address its value, 1025?

The address to the variable, which, with an integer, is also where the value is stored.

What is the variable x? Is it the address of its value, 1025?

It is the location in memory of several bytes, that hold data. How the data is interpreted depends on the code that uses it. With integers, the data is meant to represent a number (like 1025) but it could just as easily be manipulated as if it was something else, like a couple chars or a float. Data in memory is merely data in memory - what gives it meaning is how it is used.

What is *y? Is it the address of 1025 = variable x ?

1025 is merely the data stored at the address of 'x', the value stored in those bytes of memory doesn't change the location of 'x' at all. Once 'x' is created, it's location in memory (for the duration of its lifetime) doesn't change.

So *y is x. *y 'dereferences' the address stored in 'y' (x's address), and so then you're operating on the block of memory that both 'x' and '*y' refer to.

If printing &y displays the address of y, printing &x displays the address of x, but printing x/*y just prints 1025, how would I print the address of 1025?

Printing x/*y should print 1. x = 1025. *y = 1025. 1025/1025 = 1 1025 doesn't have an address. 1025 is a bunch of bits in a few bytes somewhere. 1025 is the sequence of bits (that your code gives a meaning to, but that has no meaning on its own) stored in several bytes that is located at the address stored in 'x' and '*y'.

If we assume an integer is four bytes of memory (32 bit OS and hardware, let's say), then you have four bytes in some random location in RAM:

[01000100] [1101010] [00101001] [11010101] (gibbish binary for illustration)

The binary bits stored in those four bytes don't mean a thing, until your code decides how to interpret the meaning of those bits.

'x' is those four bytes. 1025 is converted to binary and stored in those four bytes. The address of 'x' is the address of those four bytes. 'y' is a chunk of bytes that you store the address of 'x' at. '*y' lets you operate on the bytes that 'y' stored the address of. Accessing *y gives the same bytes pointed to that x refers to.

What is &y? Is it the address in memory of the pointer variable y?

Yes.

What is the pointer variable y? Does it hold the address of the variable x?

Yes.

What is &x? Is it the address in memory of the variable x itself or is it the address its value, 1025?

It is the address of x. x can change, for example if you set it with 'x = 1024' in a later line, but its address would remain the same

What is the variable x? Is it the address of its value, 1025?

x is a variable, which means it takes up some space in memory, and the bits in that space have the integer value of 1025.

What is *y? Is it the address of 1025 = variable x ?

*y dereferences the pointer, which means it gets the value of the memory at that address. So it returns 1025.

Your 'big question' is just question #3.

1. What is &y? Is it the address in memory of the pointer variable y?

   &y is the address at which the contents of variable y are stored, those contents being the address of (pointer to) an int.

2. What is the pointer variable y? Does it hold the address of the variable x?

   Yes, y is a pointer that holds the address of variable x.

3. What is &x? Is it the address in memory of the variable x itself or is it the address its value, 1025?

   &x is the address of x, so the address in memory of the variable itself, not of the constant value you initialized it with.

4. What is the variable x? Is it the address of its value, 1025?

   The variable itself is just a region of storage in memory, an "object" in C terms. Internally, the compiler uses the name to find the address of that region of storage.

5. What is *y? Is it the address of 1025 = variable x ?

   *y is the value of whatever y points to, in this case, 1025.

6. how would I print the address of 1025?

   It is not legal to take the address of a literal constant in C (except string literals), for a variety of reasons, including that it might not have an address.

Yes, yes, the address (that's why & is called the "address of" operator), no, no.

Here's how you should think of variables in C. They are scraps of paper that you can write a value on. (The type of the value should match the type indicated on the piece of paper.) All the scraps of paper are bound together in a notebook so that you can address them by a page number, which we call the address.

Pointer variables are special pieces of paper on which you write the page number. You can later check the pointer, see which piece of paper it points to, and look at that instead.

It follows from this that:

1. A variable has an address. It's a piece of paper with a page number.
2. A value does not have an address. It's not a piece of paper, it's something like a number that you can write on a piece of paper. A number like 1025 does not have a page number, but when you write "1025" on a page you call x, then there is a page, with a page number, that has 1025 written on it.

To convince yourself that you can't take the address of a value, try something like &1025. The compiler won't allow that.

1. exactly. A pointer is a variable and as a variable has its own memory address.

2. Yes, the pointer y is initialized with the address of the variable x

3. &x is the address of the variable x. You can print it if you want to clearly see the difference.

4. The variable x is saved at a certain address in the memory. This is different from the value with which the variable is initialized, in this case 1025.

Again, to see the difference, try to print out the address of x and its value:

int x = 1025;
printf("%p", &x); //prints the address of x
printf("%d", x); //prints the value assigned to x

Last question: *y is the variable pointer and the dereference operator *, This means that you get the value saved in the variable that y points to.

Well actually if you print x/(*y) then you should get 1 as a result because you would have 1025/1025