Zeiger in der C-Programmierung: Was ist Zeiger, Typen & Beispiele

Was ist Zeiger in C?

Der Zeiger in C ist eine Variable, die die Adresse einer anderen Variablen speichert. Ein Zeiger kann auch verwendet werden, um auf eine andere Zeigerfunktion zu verweisen. Ein Zeiger kann inkrementiert / dekrementiert werden, dh um auf den nächsten / vorherigen Speicherort zu zeigen. Der Zweck des Zeigers besteht darin, Speicherplatz zu sparen und eine schnellere Ausführungszeit zu erreichen.

Verwendung von Zeigern in C.

Wenn wir eine Variable v vom Typ int deklarieren, speichert v tatsächlich einen Wert.

v ist jetzt gleich Null.

Abgesehen vom Wert hat jede Variable jedoch auch ihre Adresse (oder einfach ausgedrückt, wo sie sich im Speicher befindet). Die Adresse kann abgerufen werden, indem ein kaufmännisches Und (&) vor den Variablennamen gesetzt wird.

Wenn Sie die Adresse einer Variablen auf dem Bildschirm drucken, sieht sie wie eine völlig zufällige Zahl aus (außerdem kann sie von Lauf zu Lauf unterschiedlich sein).

Versuchen wir dies in der Praxis mit dem Zeiger im C-Beispiel

Die Ausgabe dieses Programms ist -480613588.

Was ist nun ein Zeiger? Anstatt einen Wert zu speichern, speichert ein Zeiger die Adresse einer Variablen.

Zeigervariable

Int * y = & v;

VARIABLE	ZEIGER
Ein Wert , der in einer benannten Speicher- / Speicheradresse gespeichert ist	Eine Variable , die auf die Speicher- / Speicheradresse einer anderen Variablen verweist

Zeiger deklarieren

Wie Variablen müssen Zeiger in der C-Programmierung deklariert werden, bevor sie in Ihrem Programm verwendet werden können. Zeiger können beliebig benannt werden, solange sie den Namensregeln von C entsprechen. Eine Zeigerdeklaration hat die folgende Form.

data_type * pointer_variable_name;

Hier,

• data_type ist der Basistyp des Zeigers für die Variablentypen von C und gibt den Typ der Variablen an, auf die der Zeiger zeigt.
• Das Sternchen (*: dasselbe Sternchen, das für die Multiplikation verwendet wird), das der Indirektionsoperator ist, deklariert einen Zeiger.

In diesem Tutorial zu C-Zeigern sehen Sie einige gültige Zeigerdeklarationen:

int *ptr_thing; /* pointer to an integer */int *ptr1,thing;/* ptr1 is a pointer to type integer and thing is an integer variable */double *ptr2; /* pointer to a double */float *ptr3; /* pointer to a float */char *ch1 ; /* pointer to a character */float *ptr, variable;/*ptr is a pointer to type float and variable is an ordinary float variable */

Initialisieren Sie einen Zeiger

Nachdem wir einen Zeiger deklariert haben, initialisieren wir ihn wie Standardvariablen mit einer Variablenadresse. Wenn Zeiger in der C-Programmierung nicht nicht initialisiert und im Programm verwendet werden, sind die Ergebnisse unvorhersehbar und möglicherweise katastrophal.

Um die Adresse einer Variablen zu erhalten, verwenden wir den kaufmännischen Und-Operator (&) vor dem Namen einer Variablen, deren Adresse wir benötigen. Die Zeigerinitialisierung erfolgt mit der folgenden Syntax.

Zeigersyntax

 pointer = &variable; 

Ein einfaches Programm zur Zeigerillustration ist unten angegeben:

#include int main(){int a=10; //variable declarationint *p; //pointer variable declarationp=&a; //store address of variable a in pointer pprintf("Address stored in a variable p is:%x\n",p); //accessing the addressprintf("Value stored in a variable p is:%d\n",*p); //accessing the valuereturn 0;}

Ausgabe:

Address stored in a variable p is:60ff08Value stored in a variable p is:10

Operator	Bedeutung
* *	Dient 2 Zwecken Deklaration eines Zeigers Gibt den Wert der referenzierten Variablen zurück
&	Dient nur einem Zweck Gibt die Adresse einer Variablen zurück

Arten von Zeigern in C.

Im Folgenden sind die verschiedenen Arten von Zeigern in C aufgeführt :

Null Zeiger

Wir können einen Nullzeiger erstellen, indem wir während der Zeigerdeklaration einen Nullwert zuweisen. Diese Methode ist nützlich, wenn dem Zeiger keine Adresse zugewiesen ist. Ein Nullzeiger enthält immer den Wert 0.

Das folgende Programm veranschaulicht die Verwendung eines Nullzeigers:

#include int main(){int *p = NULL; //null pointerprintf(“The value inside variable p is:\n%x”,p);return 0;}

Ausgabe:

The value inside variable p is:0

Leerer Zeiger

In der C-Programmierung wird ein ungültiger Zeiger auch als generischer Zeiger bezeichnet. Es hat keinen Standarddatentyp. Ein ungültiger Zeiger wird mit dem Schlüsselwort void erstellt. Es kann verwendet werden, um eine Adresse einer beliebigen Variablen zu speichern.

Das folgende Programm veranschaulicht die Verwendung eines ungültigen Zeigers:

#include int main(){void *p = NULL; //void pointerprintf("The size of pointer is:%d\n",sizeof(p));return 0;}

Ausgabe:

The size of pointer is:4

Wilder Zeiger

Ein Zeiger wird als wilder Zeiger bezeichnet, wenn er nicht mit irgendetwas initialisiert wird. Diese Arten von C-Zeigern sind nicht effizient, da sie auf einen unbekannten Speicherort verweisen können, was zu Problemen in unserem Programm führen und zum Absturz des Programms führen kann. Man sollte immer vorsichtig sein, wenn man mit wilden Zeigern arbeitet.

Das folgende Programm veranschaulicht die Verwendung von Wildpointern:

#include int main(){int *p; //wild pointerprintf("\n%d",*p);return 0;}

Ausgabe

timeout: the monitored command dumped coresh: line 1: 95298 Segmentation fault timeout 10s main

Andere Arten von Zeigern in 'c' sind wie folgt:

• Baumelnder Zeiger
• Komplexer Zeiger
• Nahe Zeiger
• Fernzeiger
• Riesiger Zeiger

Zeiger für direkten und indirekten Zugriff

In C gibt es zwei äquivalente Möglichkeiten, auf einen variablen Inhalt zuzugreifen und ihn zu bearbeiten

• Direkter Zugriff: Wir verwenden direkt den Variablennamen
• Indirekter Zugriff: Wir verwenden einen Zeiger auf die Variable

Lassen Sie uns dies mit Hilfe des folgenden Programms verstehen

#include /* Declare and initialize an int variable */int var = 1;/* Declare a pointer to int */int *ptr;int main( void ){/* Initialize ptr to point to var */ptr = &var;/* Access var directly and indirectly */printf("\nDirect access, var = %d", var);printf("\nIndirect access, var = %d", *ptr);/* Display the address of var two ways */printf("\n\nThe address of var = %d", &var);printf("\nThe address of var = %d\n", ptr);/*change the content of var through the pointer*/*ptr=48;printf("\nIndirect access, var = %d", *ptr);return 0;}

Nach dem fehlerfreien Kompilieren des Programms ist das Ergebnis:

Direct access, var = 1Indirect access, var = 1The address of var = 4202496The address of var = 4202496Indirect access, var = 48

Zeigerarithmetik in C.

Die Zeigeroperationen sind in der folgenden Abbildung zusammengefasst

Vorrangiger Betrieb (Vorrang)

Bei der Arbeit mit C-Zeigern müssen die folgenden Prioritätsregeln beachtet werden:

• Die Operatoren * und & haben die gleiche Priorität wie die unären Operatoren (die Negation!, Die Inkrementierung ++, die Dekrementierung--).
• Im gleichen Ausdruck werden die unären Operatoren *, &,!, ++, - von rechts nach links ausgewertet.

Wenn ein P-Zeiger auf eine X-Variable zeigt, kann * P überall dort verwendet werden, wo X geschrieben werden kann.

Die folgenden Ausdrücke sind äquivalent:

int X = 10 int * P = & Y; Für den obigen Code sind die folgenden Ausdrücke wahr
Ausdruck	Äquivalenter Ausdruck
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

Im letzteren Fall werden Klammern benötigt: Da die unären Operatoren * und ++ von rechts nach links ausgewertet werden, würde ohne die Klammern der Zeiger P inkrementiert und nicht das Objekt, auf das P zeigt.

Die folgende Tabelle zeigt die arithmetische und grundlegende Operation, die beim Umgang mit C-Zeigern verwendet werden kann

Operation	Erläuterung
Zuordnung	int * P1, * P2 P1 = P2; P1 und P2 zeigen auf dieselbe ganzzahlige Variable
Inkrementierung und Dekrementierung	Int * P1; P1 ++; P1--;
Hinzufügen eines Versatzes (Konstante)	Dadurch kann der Zeiger N Elemente in einer Tabelle verschieben. Der Zeiger wird um das N-fache der Anzahl der Bytes des Variablentyps erhöht oder verringert. P1 + 5;

C Zeiger & Arrays mit Beispielen

Traditionell greifen wir über den Index auf die Array-Elemente zu, diese Methode kann jedoch mithilfe von Zeigern entfernt werden. Zeiger erleichtern den Zugriff auf jedes Array-Element.

#include int main(){int a[5]={1,2,3,4,5}; //array initializationint *p; //pointer declaration/*the ptr points to the first element of the array*/p=a; /*We can also type simply ptr==&a[0] */printf("Printing the array elements using pointer\n");for(int i=0;i<5;i++) //loop for traversing array elements{printf("\n%x",*p); //printing array elementsp++; //incrementing to the next element, you can also write p=p+1}return 0;}

Ausgabe

12345

Durch Hinzufügen einer bestimmten Zahl zu einem Zeiger wird die Zeigerposition auf den Wert verschoben, der durch eine Additionsoperation erhalten wird. Angenommen, p ist ein Zeiger, der derzeit auf den Speicherplatz 0 zeigt. Wenn wir die folgende Additionsoperation p + 1 ausführen, wird er auf folgende Weise ausgeführt:

Da p nach dem Hinzufügen von 1 derzeit auf die Position 0 zeigt, wird der Wert zu 1, und daher zeigt der Zeiger auf die Speicherstelle 1.

C Zeiger und Zeichenfolgen mit Beispielen

Eine Zeichenfolge ist ein Array von Zeichenobjekten, die mit einem Nullzeichen '\ 0' enden. Wir können Strings mit Zeigern manipulieren. Dieser Zeiger im C-Beispiel erläutert diesen Abschnitt

#include #include int main(){char str[]="Hello Guru99!";char *p;p=str;printf("First character is:%c\n",*p);p =p+1;printf("Next character is:%c\n",*p);printf("Printing all the characters in a string\n");p=str; //reset the pointerfor(int i=0;i
Ausgabe
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
Eine andere Möglichkeit, mit Zeichenfolgen umzugehen, besteht in einer Reihe von Zeigern wie im folgenden Programm:
#include int main(){char *materials[ ] = { "iron", "copper", "gold"};printf("Please remember these materials :\n");int i ;for (i = 0; i < 3; i++) {printf("%s\n", materials[ i ]);}return 0;}
Ausgabe:
Please remember these materials:ironcoppergold
 
Vorteile von Zeigern in C.

Zeiger sind nützlich für den Zugriff auf Speicherorte.
Zeiger bieten eine effiziente Möglichkeit, auf die Elemente einer Array-Struktur zuzugreifen.
Zeiger werden sowohl für die dynamische Speicherzuweisung als auch für die Freigabe verwendet.
Zeiger werden verwendet, um komplexe Datenstrukturen wie verknüpfte Listen, Diagramme, Bäume usw. zu bilden.


Nachteile von Zeigern in C.

Zeiger sind etwas komplex zu verstehen.
Zeiger können zu verschiedenen Fehlern wie Segmentierungsfehlern führen oder auf einen Speicherort zugreifen, der überhaupt nicht benötigt wird.
Wenn einem Zeiger ein falscher Wert zugewiesen wird, kann dies zu einer Speicherbeschädigung führen.
Zeiger sind auch für Speicherverluste verantwortlich.
Zeiger sind vergleichsweise langsamer als die Variablen.
Programmierer finden es sehr schwierig, mit den Zeigern zu arbeiten; Daher liegt es in der Verantwortung des Programmierers, einen Zeiger sorgfältig zu manipulieren.

Zusammenfassung 

Ein Zeiger ist nichts anderes als ein Speicherort, an dem Daten gespeichert werden.
Ein Zeiger wird verwendet, um auf den Speicherort zuzugreifen.
Es gibt verschiedene Arten von Zeigern, wie z. B. einen Nullzeiger, einen Platzhalter, einen Leerzeiger und andere Arten von Zeigern.
Zeiger können mit Array und String verwendet werden, um effizienter auf Elemente zuzugreifen.
Wir können Funktionszeiger erstellen, um eine Funktion dynamisch aufzurufen.
Arithmetische Operationen können an einem Zeiger ausgeführt werden, der als Zeigerarithmetik bekannt ist.
Zeiger können auch auf Funktionen verweisen, die es einfach machen, verschiedene Funktionen aufzurufen, wenn ein Array von Zeigern definiert wird.
Wenn Sie einen anderen variablen Datentyp behandeln möchten, können Sie einen typecast void-Zeiger verwenden.