Shulou(Shulou.com)05/31 Report--

This article mainly introduces the relevant knowledge of "C language pointer and array application case analysis". The editor shows you the operation process through the actual case, and the operation method is simple, fast and practical. I hope this article "C language pointer and array application case analysis" can help you solve the problem.

First, pointer and array analysis-above 1. The essence of an array

An array is a continuous memory space

The space size of the array is sizeof (array_type) * array_size

The array name can be seen as a constant pointer to the first element of the array

Let's look at a piece of code:

# include int main () {int a [5] = {0}; int* p = NULL; printf ("a = 0x%X\ n", (unsigned int) (a)); printf ("a + 1 = 0x%X\ n", (unsigned int) (a + 1)); printf ("p = 0x%X\ n", (unsigned int) (p)) Printf ("p + 1 = 0x%X\ n", (unsigned int) (p + 1)); return 0;}

The output is as follows:

This code shows that the pointer operation is legal.

two。 Operation of pointer

Pointer is a special variable, and the operation rules for integers are

P + n; (unsigned int) p + n*sizeof (* p)

Conclusion ∶

When the pointer p points to an element of an array of the same type: pquo1 points to the next element of the current element; pmae1 points to the previous element of the current element.

Only subtraction is supported between pointers

The pointer type participating in the subtraction operation must be the same

P1-p2; ((unsigned int) p1-(unsigned int) p2) / sizeof (type)

Note:

The subtraction of the pointer makes sense only when two pointers point to an element in the same array, which means the subscript difference of the element the pointer refers to.

When the elements pointed to by two pointers are not in the same array, the result is not defined

Let's look at a simple pointer operation code:

# include int main () {char S1 [] = {'Haugh,' estranged, 'lumped,' o'}; int I = 0; char S2 [] = {'Walled,' oiled, 'rented,' lumped,'d'}; char* p0 = S1; char* p1 = & S1 [3]; char* p2 = S2; int* p = & I Printf ("% d\ n", p0-p1); / printf ("% d\ n", p0 + p2); / / ERROR printf ("% d\ n", p0-p2); / / printf ("% d\ n", p0-p); / / ERROR / / printf ("% d\ n", p0 * p2); / / ERROR / / printf ("% d\ n", p0 / p2); / / ERROR return 0 }

The output is as follows:

Note that the two pointers point to different arrays, although their subtraction is grammatical, but the final result is certainly meaningless.

Let's take a look at the application code of pointer operation:

# include # define DIM (a) (sizeof (a) / sizeof (* a)) int main () {char s [] = {'hags,' etrees, 'lags,' lags,'o'}; char* pBegin = s; char* pEnd = s + DIM (s); / / Key point char* p = NULL; printf ("pBegin =% p\ n", pBegin); printf ("pEnd =% p\ n", pEnd) Printf ("Size:% d\ n", pEnd-pBegin); for (pawpBegin; p pEnd points to the address after'o' = = > this is the boundary position of an edge ball in C language, and it is also a skill. At this boundary position, the pointer can be considered legal, and it can be compared with other pointers and subtracted, etc., and it is also legal in the C++ standard library.

3. Comparison of pointers

Pointers can also perform relational operations (=)

The premise of pointer relation operation is to point to elements in the same array at the same time.

The comparison operation between any two pointers (=,! =) is unlimited

The pointer type participating in the comparison operation must be the same

4. Summary

The compiler automatically allocates a continuous piece of memory space when the array is declared

When the pointer is declared, only 4 bytes of space is allocated to hold the address value

Pointers and integers can be operated, and the result is a pointer

Only subtraction is supported between pointers, and the result is the subscript difference of array elements.

Comparison operations are supported between pointers, and their types must be the same.

Second, pointer and array analysis-part 1. How to access the array

Access the elements in the array in the following subject form

Access the elements in the array as a pointer

two。 Subscript form VS pointer form

When the pointer moves in a fixed increment in the array, it is more efficient than the subscript.

It is more efficient when the pointer increment is 1 and the hardware has a hardware incremental model.

Conversion between subscript form and pointer form

A [n] * (a + n) * (n + a) n [a]

Note: the optimization rate of generated code in modern compilers has been greatly improved, and when the increment is fixed, the efficiency of the subscript form is equal to that of the pointer form, but from the point of view of readability and code maintenance, the subscript form is better.

Let's take a look at the access code of an array:

# include int main () {int a [5] = {0}; int* p = a; int iTuno; for (iTun0; I

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.