Der Zeiger in der Sprache C ist eine Variable, die die Adresse einer anderen Variablen speichert. Diese Variable kann vom Typ int, char, array, function oder einem beliebigen anderen Zeiger sein. Die Größe des Zeigers hängt von der Architektur ab. In der 32-Bit-Architektur beträgt die Größe eines Zeigers jedoch 2 Byte.

Betrachten Sie das folgende Beispiel, um einen Zeiger zu definieren, der die Adresse einer Ganzzahl speichert.

 int n = 10; int* p = &n; // Variable p of type pointer is pointing to the address of the variable n of type integer. 

Einen Zeiger deklarieren

Der Zeiger in der Sprache C kann mit * (Sternchensymbol) deklariert werden. Es wird auch als Indirektionszeiger bezeichnet, der zum Dereferenzieren eines Zeigers verwendet wird.

 int *a;//pointer to int char *c;//pointer to char 

Zeigerbeispiel

Nachfolgend finden Sie ein Beispiel für die Verwendung von Zeigern zum Drucken der Adresse und des Werts.

Wie Sie in der obigen Abbildung sehen können, speichert die Zeigervariable die Adresse der Zahlenvariablen, d. h. fff4. Der Wert der Zahlenvariablen ist 50. Die Adresse der Zeigervariablen p ist jedoch aaa3.

Mit Hilfe von * ( Indirektionsoperator ), können wir den Wert der Zeigervariablen p ausgeben.

Python neue Zeile

Sehen wir uns das Zeigerbeispiel an, wie es für die obige Abbildung erläutert wurde.

 #include int main(){ int number=50; int *p; p=&number;//stores the address of number variable printf('Address of p variable is %x 
',p); // p contains the address of the number therefore printing p gives the address of number. printf('Value of p variable is %d 
',*p); // As we know that * is used to dereference a pointer therefore if we print *p, we will get the value stored at the address contained by p. return 0; } 

Ausgabe

 Address of number variable is fff4 Address of p variable is fff4 Value of p variable is 50 

Zeiger auf Array

 int arr[10]; int *p[10]=&arr; // Variable p of type pointer is pointing to the address of an integer array arr. 

Zeiger auf eine Funktion

 void show (int); void(*p)(int) = &display; // Pointer p is pointing to the address of a function 

Zeiger auf Struktur

 struct st { int i; float f; }ref; struct st *p = &ref; 

Vorteil des Zeigers

1) Zeiger reduziert den Code Und verbessert die Leistung Es wird zum Abrufen von Zeichenfolgen, Bäumen usw. verwendet und mit Arrays, Strukturen und Funktionen verwendet.

2) Wir können mehrere Werte von einer Funktion zurückgeben mit dem Zeiger.

3) Es macht dich dazu in der Lage auf einen beliebigen Speicherort zugreifen im Speicher des Computers.

Verwendung des Zeigers

Es gibt viele Anwendungen von Zeigern in der Sprache C.

1) Dynamische Speicherzuweisung

In der Sprache C können wir Speicher mithilfe der Funktionen malloc() und calloc() dynamisch zuweisen, wobei der Zeiger verwendet wird.

Pyspark SQL

2) Arrays, Funktionen und Strukturen

Zeiger in der Sprache C werden häufig in Arrays, Funktionen und Strukturen verwendet. Es reduziert den Code und verbessert die Leistung.

Adresse des (&) Operators

Die Adresse des Operators „&“ gibt die Adresse einer Variablen zurück. Wir müssen jedoch %u verwenden, um die Adresse einer Variablen anzuzeigen.

 #include int main(){ int number=50; printf('value of number is %d, address of number is %u',number,&number); return 0; } 

Ausgabe

 value of number is 50, address of number is fff4 

Null Zeiger

Ein Zeiger, dem kein anderer Wert als NULL zugewiesen ist, wird als NULL-Zeiger bezeichnet. Wenn zum Zeitpunkt der Deklaration keine Adresse im Zeiger angegeben werden muss, können Sie einen NULL-Wert zuweisen. Es wird einen besseren Ansatz bieten.

 int *p=NULL; 

In den meisten Bibliotheken ist der Wert des Zeigers 0 (Null).

Zeigerprogramm zum Vertauschen zweier Zahlen ohne Verwendung der dritten Variablen.

 #include int main(){ int a=10,b=20,*p1=&a,*p2=&b; printf('Before swap: *p1=%d *p2=%d',*p1,*p2); *p1=*p1+*p2; *p2=*p1-*p2; *p1=*p1-*p2; printf('
After swap: *p1=%d *p2=%d',*p1,*p2); return 0; } 

Ausgabe

Sortieralgorithmen für Einfügungen

 Before swap: *p1=10 *p2=20 After swap: *p1=20 *p2=10 

Komplexe Hinweise lesen

Beim Lesen der komplexen Zeiger in C müssen mehrere Dinge berücksichtigt werden. Sehen wir uns die Priorität und Assoziativität der Operatoren an, die in Bezug auf Zeiger verwendet werden.

Hier müssen wir Folgendes beachten:

• (): Dieser Operator ist ein Klammeroperator, der zum Deklarieren und Definieren der Funktion verwendet wird.
• []: Dieser Operator ist ein Array-Indexoperator
• *: Dieser Operator ist ein Zeigeroperator.
• Bezeichner: Dies ist der Name des Zeigers. Diesem wird immer die Priorität zugewiesen.
• Datentyp: Der Datentyp ist der Typ der Variablen, auf die der Zeiger zeigen soll. Es enthält auch den Modifikator wie „signed int“, „long“ usw.).

So lesen Sie den Zeiger: int (*p)[10].

Um den Zeiger lesen zu können, müssen wir sicherstellen, dass () und [] die gleiche Priorität haben. Daher muss hier ihre Assoziativität berücksichtigt werden. Die Assoziativität verläuft von links nach rechts, daher liegt die Priorität bei ().

Innerhalb der Klammer () haben der Zeigeroperator * und der Zeigername (Bezeichner) p die gleiche Priorität. Daher muss hier ihre Assoziativität berücksichtigt werden, die von rechts nach links verläuft, sodass die Priorität an p und die zweite Priorität an * geht.

Weisen Sie [] die 3. Priorität zu, da der Datentyp die letzte Priorität hat. Daher sieht der Zeiger wie folgt aus.

• char -> 4
• * -> 2
• p -> 1
• [10] -> 3

Der Zeiger wird gelesen, da p ein Zeiger auf ein Array von Ganzzahlen der Größe 10 ist.

Namensverzeichnis Linux ändern

Beispiel

Wie ist der folgende Hinweis zu lesen?

 int (*p)(int (*)[2], int (*)void)) 

Erläuterung

Dieser Zeiger wird gelesen, da p ein Zeiger auf eine solche Funktion ist, die den ersten Parameter als Zeiger auf ein eindimensionales Array von ganzen Zahlen der Größe zwei und den zweiten Parameter als Zeiger auf eine Funktion akzeptiert, deren Parameter ungültig und deren Rückgabetyp ist die ganze Zahl.