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

I. pointer

1. Use the pointer

What is a pointer? What is the memory address? What is the value of the pointer? A pointer is a variable that stores the memory address of a computer. Reading data from the memory that the pointer points to is called the value of the pointer. Pointers can point to specific types of variable addresses, such as int, long, and double. Pointers can also be void types, NULL pointers, and uninitialized pointers.

Depending on where it appears, the operator * can be used either to declare a pointer variable or as the value of the pointer. When used to declare a variable, * indicates that a pointer is declared here. In other cases, * is used to indicate the value of the pointer. & is the address operator that refers to a memory address. By using the & operator before the variable name, we can get the memory address of the variable.

For example:

# include

Int main ()

{

Int*ptr; / / declare an int pointer

Int val = 1; / / declare an int value

Ptr = & val; / / assigns a reference to the int value to the pointer

Int deref = * ptr; / / A pair of pointers take values and print what is stored in the pointer address

Printf ("deref address =% ld, value =% d\ n", ptr, deref)

In line 2, we declare an int pointer through the * operator. Then we declare an int variable and assign it to 1. Then we initialize our int pointer with the address of the int variable. Next, take the value of the int pointer and initialize the int pointer with the memory address of the variable. Finally, we print out the value of the variable with a content of 1.

The & val in line 6 is a reference. After the val variable declares and initializes memory, we can reference the memory address of the variable directly by using the address operator before the variable name.

In line 8, we once again use the * operator to value the pointer to directly get the data in the memory address that the pointer points to. Because the type declared by the pointer is int, the value fetched is the int value stored at the memory address that the pointer points to.

Here you can compare the relationship between pointers, references, and values to envelopes, mailbox addresses, and houses. A pointer is like an envelope on which we can fill in the mailing address. A reference (address) is like an email address, it is the actual address. The value is like the house corresponding to the address. We can erase the address on the envelope and write down another address we want, but this behavior has no effect on the house.

2. Pointers and arrays

The array of C language represents a contiguous memory space that is used to store multiple objects of a particular type. In contrast, pointers are used to store a single memory address. Arrays and pointers are not the same structure and therefore cannot be converted to each other. The array variable points to the memory address of the first element of the array.

For example:

# include

Int main ()

{

Int myarray [4] = {1, 2, 3, 0}

Int * ptr = myarray

Printf ("ptr address =% ld, value * ptr=%d\ n", ptr,*ptr)

Ptr++

Printf ("ptr address =% ld, value * ptr=%d\ n", ptr,*ptr)

Ptr++

Printf ("ptr address =% ld, value * ptr=%d\ n", ptr,*ptr)

Ptr++

Printf ("ptr address =% ld, value * ptr=%d\ n", ptr,*ptr)

}

Summary:

The pointer to the pointer can be understood in this way. First of all, the pointer to the pointer can regard it as a special variable. Since it is a variable, it can store different elements. For example, the × × × variable int a can store ordinary integer data, as long as the value is paid to a, but the element stored in the pointer to the pointer is special, and the stored element is generally the pointer variable that stores the address. For example, I have three pointer variables, int * p1 and p2, then I can define a special variable int * p. I can pay the address of p1 to p, or I can pay the address of p2 to p. For example, p=&p1, (similar to int adirection int * tGramploca), then p represents the address of the variable p1 or p2 he points to, while the variable p points to is a pointer variable, * p represents the value in the pointer variable (note value is actually an address), and * p represents the content (value) of the storage unit pointed to by the content (address) of the pointer variable it points to.

2. Linked list

Linked list is a kind of data structure, and its biggest advantage is that it can allocate dynamic memory to the data, so it doesn't have to allocate a space for the system to store students' information like at the beginning.

The linked list, first of all, can be subdivided into small structural variables, which are connected end to end in the linked list, just like an iron chain, and each small structural variable can be divided into two parts in a large direction, one of which is-- covers all the information in the structural variable. The other part is the part that links each structural variable-- the pointer.

For example:

Typedefstruct node

{

Char name [20]

Struct node * link

} stud

This defines the structure of a single linked list, where char name [20] is a character array for storing names, and the pointer * link is a pointer for storing its immediate successors. After defining the structure of the linked list, as long as the appropriate data is stored in the data field when the program is running, if there is a successor node, point the link field to its direct successor, if not, set it to NULL.

Third, the difference between pointers and arrays

1. The difference between statements

Pointer: exterenint * x

Array: externint [] y []

two。 The pointer is the address where the data is saved.

An array is to save data.

3. Pointers are dynamic data structures used for.

An array is a data structure that stores a fixed number and has the same data type.

Once an array is defined, its base address, urine and urine are fixed and are immutable within the effective use range of the array.

However, the pointer has a strong dynamic characteristic, and it can dynamically point to any variable of that type (definition decision), which determines that it has more flexibility.

4. An array opens up a continuous memory space, and the identifier of the array itself represents the entire array.

A pointer allocates memory the size of a pointer and points its value to a valid memory space.

5. The pointer is a variable that can be assigned, and the value of the variable is the address of another variable. So, since the pointer is a variable, the pointer must have its own storage space, but the value in that storage space is an address value, not anything else.

The array name is just a symbol, not a variable, and cannot be assigned. It does not have its own storage space.

6. The difference in computing speed. Generally speaking, it is faster to use pointers, because in actual operations, the array subscript representation is always converted into a pointer representation by storing the mapping function, and the memory is accessed by its address, which requires multiplication and addition.

7. The array has better readability, and the pointer has more flexibility. In general, it is convenient to use subscripts for random access to discontinuous elements in some multi-dimensional arrays, and pointers are fast and convenient when accessing arrays in ascending (decreasing) order.

8. Access method: the pointer is indirect access, first get the contents of the pointer as the address, and then go to the address to access the data

The array is accessed directly, and the array name is the address.

IV. Student name management system

# include

# include

# include

# include

# define N 3

Typedef struct node

{

Charname [20]

Struct node*link

} stud

Stud * creat (int n) / * function to create a single linked list * /

{

Stud*p,*h,*s

Int i

If ((h = (stud*) malloc (sizeof (stud) = = NULL)

{

Printf ("memory space cannot be allocated!")

Exit (0)

}

H-> name [0] ='\ 0'

H-> link=NULL

Pairh

For (iS0th ilinksand)

Printf ("Please enter the name of the% d person:", iTun1)

Scanf ("% s", s-> name)

S-> link=NULL

Pairs

}

Return (h)

}

Stud * search (stud * hmaine char * x) / * find function * /

{

Stud * p

Char * y

Pairh-> link

While (paired null)

{

Yroomp-> name

If (strcmp (yperimex) = = 0)

Return (p)

Elsep=p- > link

}

If (p==NULL)

Printf ("data not found!")

}

Stud * search3 (stud * hling chartered x)

/ * another lookup function that returns the pointer to the direct precursor node of the previous lookup function

H is the header pointer and x is the pointer to the name to be found

In fact, the algorithm of this function is the same as the above search algorithm, except that there is an extra pointer s, and s always points to the direct precursor of the node pointed to by the pointer p.

The result returns s, which is the previous node of the node to be found * /

{

Stud * pjime

Char * y

Pairh-> link

Sphinch

While (paired null)

{

Yroomp-> name

If (strcmp (yperimex) = = 0)

Return (s)

Else

{

Pairp-> link

Swatches-> link

}

}

If (p==NULL)

Printf ("data not found!")

}

Void insert (stud * p) / * insert function, insert * / after pointer p

{

Charstuname [20]

Stud * s; / * pointer s is the * / that holds the address of the new node.

If ((s = (stud*) malloc (sizeof (stud) = = NULL)

{

Printf ("memory space cannot be allocated!")

Exit (0)

}

Printf ("Please enter the name of the person you want to insert:")

Scanf ("% s", stuname)

Strcpy (s-> name,stuname); / * copy the array elements pointed to by the pointer stuname to the data field of the new node * /

S-> link=p- > link; / * point the link domain of the new node to the successor node of the original p node * /

The link domain of the p-> link=s;/*p node points to the new node * /

}

Void del (stud * x stud * y) / * delete function, where y is the pointer of the node to be deleted and x is the pointer of the previous node of the node to be deleted * /

{

Stud * s

Swiny

X-> link=y- > link

Free (s)

}

Void print (stud * h)

{

Stud * p

Pairh-> link

Printf ("data information is:\ n")

While (paired null)

{

Printf ("% s\ n", & * (p-> name))

Pairp-> link

}

}

Void quit ()

{

Exit (0)

}

Void menu (void)

{

System ("cls")

Printf ("\ t\ t\ t single linked list C language implementation example\ n")

Printf ("\ t\ t |-|\ n")

Printf ("\ t\ t | |\ n")

Printf ("\ t\ t | [1] create a new table |\ n")

Printf ("\ t\ t | [2] search data |\ n")

Printf ("\ t\ t | [3] insert data |\ n")

Printf ("\ t\ t | [4] Delete data |\ n")

Printf ("\ t\ t | [5] print data |\ n")

Printf ("\ t\ t | [6] exit |\ n")

Printf ("\ t\ t | |\ n")

Printf ("\ t\ t | if you have not created a new table, create it first! |\ n")

Printf ("\ t\ t | |\ n")

Printf ("\ t\ t |-|\ n")

Printf ("\ t\ t Please enter your options (1-6):")

}

Main ()

{

Int choose

Stud*head,*searchpoint,*forepoint

Charfullname [20]

While (1)

{

Menu ()

Scanf ("d", & choose)

Switch (choose)

{

Case 1:

Head=creat (N)

Break

Case 2:

Printf ("enter the name of the person you are looking for:")

Scanf ("% s", fullname)

Searchpoint=search (head,fullname)

Printf ("the name of the person you are looking for is:% s", * & searchpoint- > name)

Printf ("\ nPress enter to return to the main menu.")

Getchar (); getchar ()

Break

Case 3:printf ("enter who you want to insert after:")

Scanf ("% s", fullname)

Searchpoint=search (head,fullname)

Printf ("the name of the person you are looking for is:% s", * & searchpoint- > name)

Insert (searchpoint)

Print (head)

Printf ("\ nPress enter to return to the main menu.")

Getchar (); getchar ()

Break

Case 4:

Print (head)

Printf ("\ nenter the name of the person you want to delete:")

Scanf ("% s", fullname)

Searchpoint=search (head,fullname)

Forepoint=search3 (head,fullname)

Del (forepoint,searchpoint)

Break

Case 5:

Print (head)

Printf ("\ nPress enter to return to the main menu.")

Getchar (); getchar ()

Break

Case6:quit ()

Break

Default:

Printf ("you typed illegal characters! press enter to return to the main menu.")

System ("cls")

Menu ()

Getchar ()

}

}

}

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.