Ask C about the output of addresses

However, it is clear that this is problematic because variable a is not assigned at all.

The third: the key to the symbol & addition depends on what you want to output, and what variable a is, which is determined by both.

The process is a bit complicated.

First, I will affirm the fruits of my labor, and then I will talk about it in detail.

The first one: printf("%p",a)

This is the value of output a.

printf("%p",&a)

This is the address where the main output stores the a-value.

To output the address of the pointer variable b, just printf("%p",&b);

Remember that there is an amperand sign, which indicates the address.

The first, int a; The integer variable a is not assigned, so the value of a is garbled, and &a is the memory address of the a variable.

the second, int*b; b is an integer pointer, after b=&a, the value of b is the memory address of the a variable, and if the address of b is output, then it is &b

Third, what symbols are needed to be related to your needs, for example, if you want to print out the value of a, then it is a, and if you want to view the memory address of a, then you will &a

printf("%p",a);and printf("%p",&a);The difference is that the former outputs the address of a, while the latter outputs the address of the parameter, and the address of a is stored in the parameter.

The second fill in b is the address of the a variable, and you want to output the address of the pointer variable b and fill in &b

The third & takes the address, which is used when outputting variables, but not when outputting pointers.

It can be understood that the memory is a big hotel, and the rooms in it have house numbers, which are the value of the address, and the room is a space (how big is the space?). For example, int can be calculated with sizeof(int)).

This address is worth and is represented by &x (hex) in hexadecimal. Or %p print address.

The (first) address of the array is the name of the array, e.g. int s[10], where s is the address.

The pointer, p is the pointer itself, and *p is the address stored in the space (in the room, p has its own room number, and *p is a room number stored in p's room).

But when you really use it, you generally don't use the address to do the operation, but use the data in the address. gets(s) is also an input of data into the contiguous space of this address.

CPU registers and memory will define the starting address as zero, and then use the offset to find the corresponding address. For x86, the address is an unsigned int that occupies 4bytes; x64 is an unsigned int with an address of 8 bytes

is a specific number.

In the memory space, these data are stored in the memory space, how to find it, is to find it by the address.

Binary bits are the most basic units called bytes

The computer makes a group of 8 of these bits into bytes.

Number each byte, this is the address, through this address, you can find the data you want like a community, want to find an owner, through a few buildings, a few units, a few floors to find, hehe, two addresses can do subtraction operations (indicating how many bytes are separated between two addresses), or an address minus a constant.

That's an interesting question:)

An address is an address, just a string of numbers.

If you want to output the corresponding content, then you need to know two things:

a, you need to know how many bytes of memory you need to save this content, in other words, you need to know how much you need to explain.

How many bytes of memory space can be used to output the contents of the storage;

b, the second thing you need to know is how to interpret this length of memory, whether it is explained in terms of unsigned integers or single-precision floating-point numbers.

In C C++, the concept that tells you both of these things is the type of data that is stored at the address.

So, let's say you only have one address of type ul on hand, and you want to interpret the four bytes at that address as none.

sign integer, then you have to write something like this: *unsigned int *)0xabcdef12 ; Otherwise, it is to be interpreted as monosperm.

0xabcdef12 begins with a byte (note that it's not four bytes, but a byte) is interpreted as an unsigned

char, here's how it works: *unsigned char *)0xabcdef12.

So, what type of long bytes you interpret and what kind of content you can take out is up to you. :

As long as the address is not empty, it can be output.