Shulou(Shulou.com)06/03 Report--

How to deeply understand the C language pointer and occupy the memory space, I believe that many inexperienced people are at a loss about this. Therefore, this paper summarizes the causes and solutions of the problem. Through this article, I hope you can solve this problem.

First, understand the memory space.

This article has a lot of text, and it will be a little boring. Reading it together with pictures and text can relieve the boredom. Read patiently!

First know the memory address, in order to better understand the pointer!

We can think of memory as a long freight train with many carriages of the same size, and each car is exactly equivalent to one byte in memory. These carriages are loaded with different goods, just as we have to store all kinds of data in our memory.

Talk about it a little more.

We can usually listen to music, watch videos and articles on the computer, but what we see is the data in every "car" in memory, which eventually evolved from binary 0pin 1.

Although videos, articles, music and other information are different in our eyes, for computers, they are all represented in binary form in memory.

Because we need to know where to store or retrieve data, every byte in memory has a corresponding number, just like a train car number. The number of each byte in this memory is what we often call the memory address, which is addressed in byte after byte order. As shown in the following figure:

Ask more questions about everything. Why?

1. Why do all memory addresses start with 0x?

The beginning of 0x represents the meaning expressed in hexadecimal.

two。 Why do we usually see memory addresses like this? As shown in the figure:

Because of the large memory capacity and naturally more large bytes, more bits are needed to address the memory address. The (0x00...) memory address in the picture above is just easy to understand!

3. Why am I so lame?

Ha. Don't you count * in your mind?

About memory byte

A memory address stores only 1 byte (Byte); 1 byte equals 8-bit binary, and the 0 or 1 of each bit binary is called "bit"; the bit is the smallest unit, and the byte is a collection of bits, also a unit

Memory is allocated to the data type address as follows:

Char: assign an address to one byte; int: assign four addresses to four bytes; and there are long, float, double and other types waiting for you to test.

You can use sizeof for authentication:

# includeint main () {printf ("sizeof (char) =% u\ n", sizeof (char)); printf ("sizeof (int) =% u\ n", sizeof (int)); return 0;}

The results are as follows:

Second, understand the pointer

Do not think that the pointer is too complex, the essence of the pointer is the memory "address", it can be said that the pointer is the address, in fact, the pointer is the variable that holds the address.

Compare ordinary variables with pointer variables:

Char a; / / defines a variable a to hold data of type char; char * b; / defines a pointer variable b to hold a memory address where the data must be of type char.

For example, assign values to pointer variables:

# includeint main () {char a = 5; / / char type occupies a byte; char * b = & a; / / "&" takes the address of the variable and takes out the address of an in memory; / / assigns a value to the b pointer, where the b variable stores the an address. Printf ("I am the value of variable a:% d\ n", * b); / / * b means to output the data on the address stored in b; / / prove that the address stored on b is the address of a; printf ("I am the address of a:% p\ n", & a); printf ("I am the value of variable b:% p\ n", b); return 0;}

The output is as follows:

I am the value of variable a: 5 I am the address of a: 000000000062FE17 I am the value of variable b: 000000000062FE17

To understand by drawing:

Modify the value of a variable by pointer indirectness

Char a = 5; char * b = & a Bing printf ("initial value: a% d description% d\ n", a minute b); * b = 12; / / what you actually operate on is the value of the variable an itself Printf ("modified: a minute% d journal% d\ n", a moment b);-- the output is: initial value: Apost5, after modification: axiom 12.

The concept of pointer type

We know that char type data is only one byte, many types require multiple bytes to store, and data like int type requires four bytes to store (the length may vary depending on the platform).

For the int type, the pointer starts at the current byte (address) and four bytes (address) are all values belonging to the variable, while for the char type, only the current byte (address) is indicated. The code is as follows:

Int a = 259 ntint * p1 = & a char * p2 = (p2 *) & a; / / the type printf needs to be cast here ("* p1bot% dpapering p2characters% d\ n", * p1minting p2);-output: * p1mm 259coverages p2q3

To make it easier to understand by drawing:

From the above we already know something about the int type pointer. The output of * p1 is within our budget, but why is the value of the output of * p2 3?

Key point, knock on the blackboard!

Because the computer uses binary to represent numbers, the above decimal conversion binary is [100000011], because an int type variable takes up four bytes, 8-bit binary to one byte, after completing the high-order 0, then [00000000 00000000 00000001 000011], every 8-bit binary (one byte) is converted to decimal, then [0   0   1   3].

At this point you should almost understand why the output value of * p2 is 3, but there is a concept in the memory address called "size mode", there will be two different sorts of sorting: [0   0   1   3] or [3   1   0   0].

Since the address of * p2 read by the computer is 0x00, you can directly output the data on this address. You can also try to change 259 to 258, 257, etc., to see if it is what you said.

Verify their storage address, as follows:

Int a = 259 a=0x%p * p1 = & a poster char * p2 = (p2=0x%p *) & a politics printf ("* p1 percent% d written p2percent d\ n", * p1Powerint p2); printf ("& int\ n", & a); printf ("p1=0x%p\ n", p1); printf ("p2=0x%p\ n", p2)

The output is as we expected:

When you see here, you just know the pointer, the above is what we commonly call the first-level pointer, the first-level pointer is relatively simple, there are two-level pointer and multi-level pointer, more around, more difficult to understand, and then introduce the second-level pointer.

Before talking about the second-level pointer, do we have any questions: what is the first-level pointer? What is a secondary pointer? What's the difference between the two?

The first-level pointer stores the address of the variable, through which the data of the variable is "directly obtained". The second-level pointer stores the address of the first-level pointer, and the second-level pointer "indirectly obtains" the data of the variable through the first-level pointer. Multi-level pointer and so on, personal understanding, what is wrong is welcome to correct.

Hold on a little longer, the highlight is "below"! [/ funny]

Secondary pointer

The pointer of the pointer is what we commonly call the secondary pointer.

What is a pointer to a pointer, such as the following code:

Char a = 5; char * p1 = & a positionchar * * p2 = & p1umbprintf ("* pairing% dGramies / p2cm% d\ n", * p1SCR / p2); / / output: * p1cm / 5 / p2x / 5

To understand by drawing:

Multi-level pointers are pointers of pointers, and so on.

Third, pointer operation

Pointer operation is calculated according to the type of pointer, and the memory allocation is different when adding 1 / minus 1 operation.

Compare int type with char type. The code is as follows:

Char type + 1: you can see from the output that the address is incremented by 1, which is in line with the saying that the char type takes up one byte.

Char c = 'hindsight] char * a = & c * for (int ifolio * *)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.