Artikelverzeichnis
1. Definition des Zeigers
Der sogenannte Zeiger bezieht sich auf die Zeigervariable (Pointer). Anhand dieses Wortes können wir erkennen, dass es auf etwas hinweist. Das heißt, in einem Computer bezieht es sich (Zeigervariable) auf eine Variable, die auf eine bestimmte Speichereinheit zeigt. Wie nachfolgend dargestellt:
int a = 0;//定义一个整形变量a
int* b = &a;//&为取地址符号，将a的地址传给b，b为指向a的一个整形指针.
2. Die Bedeutung des Zeigertyps
Oben haben wir darüber gesprochen, dass der Zeiger eine Variable ist. Aus Sicht der C-Sprache müssen wir beim Definieren einer Variablen den Typ der Variablen angeben. Wenn wir über Zeigervariablen sprechen, geben wir auch deren Typ an.
Eine Zeigervariable ist eine Variable, die auf einen Speicherort zeigt. Speicherzellen speichern Daten. Es gibt keinen sogenannten Typ einer Speichereinheit. Unter einem bestimmten Gesichtspunkt ist es tatsächlich der Typ der in der Speichereinheit gespeicherten Variablen, der den Typ unseres Zeigers bestimmt. Daher wird unser Zeigertyp durch den Typ der Variablen bestimmt, auf die er auf die gespeicherte Speicheradresse zeigt. Daher kann es int*, char* usw. geben.
Wenn der Typ des Zeigers bestimmt wird, wie viel Autorität gibt es, um den Zeiger zu dereferenzieren?
3. Zeigeroperationen
3.1 Betrieb von Zeigern und Ganzzahlen
#include <stdio.h>
//指针+- 整数
int main()
{
int arr[10] = {
1,2,3,4,5,6,7,8,9,10};
int *p = &arr[0];
int i = 0;
int sz = sizeof(arr)/sizeof(arr[0]);
for(i=0; i<sz; i++)
{
printf("%d ", *(p+i));//p+i 这⾥就是指针+整数
}
return 0;
Das Ergebnis ist
1 2 3 4 5 6 7 8 9 10
Wenn wir den Code ausführen, können wir sehen, dass jedes Element des Arrays der Reihe nach gedruckt wird. *(p+i) entspricht p[i] und die Ganzzahl entspricht dem Element (Position) im Array.
3.2 Zeiger-Zeiger
//指针-指针
#include <stdio.h>
int my_strlen(char *s)
{
char *p = s;
while(*p != '\0' )
p++;
return p-s;//非零元素的末地址-初地址
}
int main()
{
printf("%d\n", my_strlen("abc"));
return 0;
}
Das Ergebnis ist
3
Als Ergebnis der Operation können wir sehen, dass die Anzahl der Elemente zwischen den beiden Zeigern zurückgegeben wird.
3.3 Relationale Operationen auf Zeigern
#include <stdio.h>
int main()
{
int arr[10] = {
1,2,3,4,5,6,7,8,9,10};
int *p = &arr[0];
int i = 0;
int sz = sizeof(arr)/sizeof(arr[0]);
while(p<arr+sz) //指针的⼤⼩⽐较
{
printf("%d ", *p);
p++;
}
return 0;
}
Das Ergebnis ist
1 2 3 4 5 6 7 8 9 10
Das Ergebnis der Codeausführung ist, dass jedes Element des Arrays gedruckt wird.
Im Code speichert p die Adresse des ersten Elements und arr + sz (das erste Element + die Anzahl der Elemente ist die Adresse des letzten Elements).
4. Array von Zeigern
Aus grammatikalischer Sicht. Ein Zeiger verändert ein Array, das heißt, er verweist auf ein Array. Ein Array von Zeigern ist ein Array von Zeigern . wie
int a = 0;
int* b = &a;
int* p[1] = {
b};
5. Wie heißt das Zeiger-Array?
Im Allgemeinen ist der Array-Name die Adresse des ersten Elements. (Zwei Ausnahmen: 1 ist die Verwendung von sizeof (Array-Name). Zu diesem Zeitpunkt wird das Array als gesamtes Array deklariert. 2. & Der Array-Name stellt auch das gesamte Array dar.) Daher ist der Zeiger-Array-Name der Zeiger des ersten
Elements (Zeiger), also der Zeiger der zweiten Ebene.
#include <stdio.h>
int main()
{
int a = 0;
int* b = &a;
int* p[1] = {
b};
printf("%d",**p);
return 0;
}
Das Ergebnis ist
0
Wenn wir drucken müssen, müssen wir es zweimal dereferenzieren.
6. Array-Zeiger
Aus grammatikalischer Sicht. Arrays modifizieren Zeiger, die auf Zeiger verweisen. Ein Array-Zeiger ist nur ein Zeiger auf ein Array . wie
int (*p)[10] = {
0};
p wird zuerst mit * in Klammern und dann mit [10] kombiniert, was auf das Array zeigt
7. Funktionszeiger
Lassen Sie uns hier zunächst die Schlussfolgerung ziehen: Auch Funktionen haben Adressen.
Dann ist ein Zeiger eine Variable, die speziell zum Zeigen auf eine Adresse verwendet wird. Daher kann ein Zeiger auch zum Zeigen auf eine Funktion verwendet werden, die als Funktionszeiger bezeichnet wird. wie
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("test: %p\n", test);
printf("&test: %p\n", &test);
return 0;
}
Das Ergebnis ist wie folgt:
test: 005913CA
&test: 005913CA
8. Array von Funktionszeigern
Aus grammatikalischer Sicht. Der Funktionszeiger ändert das Array, das heißt, das Wesentliche ist ein Array. Ein Funktionszeiger-Array bezieht sich auf ein Array , das Funktionszeiger speichert . wie
int (*parr1[3])();
In den Klammern im Inneren wird parr1 zuerst mit einem Array kombiniert, um ein Array darzustellen, und dann mit * kombiniert, um ein Array von Zeigern darzustellen, und außerhalb ist es eine Funktion, deren Rückgabewert ein int-Modell ist und keine formalen Parameter hat. Zusammenfassend , es ist ein Array von Funktionszeigern (außen > „innen“)
PS: Die meisten der zitierten Codes sind aus den Kursunterlagen des Bit-Beschäftigungskurses „Peng Ge C Language“ kopiert.