Zeiger in C: Was ist ein Zeiger in der C-Programmierung? Typen

Was ist ein Zeiger in C?

A Zeiger In C ist ein Zeiger eine Variable, die die Adresse einer anderen Variable speichert. Ein Zeiger kann auch auf einen anderen Zeiger oder eine Funktion verweisen. Durch Inkrementieren oder Dekrementieren eines Zeigers kann auf die nächste bzw. vorherige Speicheradresse gezeigt werden. Der Zweck eines Zeigers besteht darin, Speicherplatz zu sparen und eine schnellere Ausführung zu ermöglichen.

So verwenden Sie Zeiger in C

Wenn wir eine Variable v vom Typ int deklarieren, speichert v einen Wert. Jede Variable hat neben ihrem Wert auch eine Adresse, also ihren Speicherort. Die Adresse kann durch Voranstellen eines kaufmännischen Und-Zeichens (&) vor den Variablennamen abgerufen werden. Gibt man die Adresse einer Variable aus, erscheint sie als Zufallszahl, die sich bei jedem Ausführen ändern kann.

Anstatt einen Wert zu speichern, speichert ein Zeiger die Adresse einer Variablen. Zum Beispiel:

int *y = &v;

Deklarieren eines Zeigers

Wie Variablen, Zeiger in C-Programmierung Sie müssen deklariert werden, bevor sie verwendet werden können. Eine Zeigerdeklaration hat folgende Form:

data_type *pointer_variable_name;

Dabei steht: Datentyp Der Basistyp des Zeigers gibt den Typ der Variablen an, auf die der Zeiger verweist. Das Sternchen (*), dasselbe Symbol wie für die Multiplikation, ist der Deklarationsoperator, der einen Zeiger deklariert. Einige gültige Zeigerdeklarationen sind:

int    *ptr_thing;       /* pointer to an integer */
int    *ptr1, thing;     /* ptr1 points to an int; thing is an int */
double *ptr2;           /* pointer to a double */
float  *ptr3;           /* pointer to a float */
char   *ch1;            /* pointer to a character */

Initialisiere einen Zeiger

Nach der Deklaration eines Zeigers initialisieren wir ihn mit einer Variablenadresse. Wird ein Zeiger nicht initialisiert verwendet, kann dies unvorhersehbare und potenziell katastrophale Folgen haben. Um die Adresse einer Variablen zu erhalten, verwenden Sie den kaufmännischen Und-Operator (&) vor dem Variablennamen.

pointer = &variable;

Nachfolgend ein einfaches Programm zur Veranschaulichung eines Zeigers:

#include <stdio.h>
int main()
{
   int a = 10;     // variable declaration
   int *p;         // pointer variable declaration
   p = &a;        // store address of a in pointer p
   printf("Address stored in p is: %x\n", p);  // access the address
   printf("Value stored in p is: %d\n", *p);    // access the value
   return 0;
}

Ausgang:

Address stored in p is: 60ff08
Value stored in p is: 10

Arten von Zeigern in C

Null Zeiger

Wir erzeugen einen Nullzeiger, indem wir ihm bei der Deklaration den Wert NULL zuweisen. Dies ist nützlich, wenn dem Zeiger noch keine Adresse zugewiesen ist. Ein Nullzeiger enthält immer den Wert 0.

#include <stdio.h>
int main()
{
   int *p = NULL;     // null pointer
   printf("The value inside variable p is: %x", p);
   return 0;
}

Leerer Zeiger

Ein Void-Pointer, auch generischer Pointer genannt, hat keinen festgelegten Datentyp. Er wird mit dem Schlüsselwort `void` erzeugt und kann die Adresse einer beliebigen Variablen speichern:

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

Wilder Vorstehhund

Ein Zeiger wird als Wildpointer bezeichnet, wenn er nicht initialisiert ist. Solche Zeiger sind ineffizient, da sie auf einen unbekannten Speicherort verweisen können, was zu Problemen und einem Programmabsturz führen kann. Gehen Sie daher stets vorsichtig mit Wildpointern um.

#include <stdio.h>
int main()
{
   int *p;          // wild pointer
   printf("%d", *p);
   return 0;
}

Zu den anderen Zeigertypen in C gehören der hängende Zeiger, der komplexe Zeiger, der nahe Zeiger, der ferne Zeiger und der riesige Zeiger.

Direkte und indirekte Zugriffszeiger

In C gibt es zwei gleichwertige Möglichkeiten, auf den Inhalt einer Variablen zuzugreifen und ihn zu bearbeiten. Der direkte Zugriff erfolgt über den Variablennamen, während der indirekte Zugriff einen Zeiger auf die Variable verwendet:

#include <stdio.h>
int var = 1;        /* declare and initialize an int variable */
int *ptr;           /* declare a pointer to int */
int main(void)
{
   ptr = &var;       /* point ptr to var */
   printf("\nDirect access, var = %d", var);
   printf("\nIndirect access, var = %d", *ptr);
   *ptr = 48;        /* change var through the pointer */
   printf("\nIndirect access, var = %d", *ptr);
   return 0;
}

Zeigerarithmetik in C

Beim Umgang mit Zeigern sind folgende Prioritätsregeln zu beachten: Die Operatoren * und & haben dieselbe Priorität wie die unären Operatoren (Negation !, Inkrement ++, Dekrement –). Innerhalb desselben Ausdrucks werden die unären Operatoren *, &, !, ++ und – von rechts nach links ausgewertet. Zeigt ein Zeiger P auf eine Variable X, so kann *P überall dort verwendet werden, wo X geschrieben werden kann. Die folgenden Ausdrücke sind äquivalent:

Im letzten Fall sind Klammern erforderlich: Da die unären Operatoren * und ++ von rechts nach links ausgewertet werden, würde ohne Klammern der Zeiger P inkrementiert, nicht das Objekt, auf das er zeigt. Die für Zeiger verfügbaren arithmetischen Operationen sind Zuweisung, Inkrementierung und Dekrementierung sowie Addition und Subtraktion.tracdurch Angabe eines ganzzahligen Offsets, der den Zeiger um diese Anzahl Elemente verschiebt (jeder Schritt entspricht der Größe des Basistyps in Bytes).

C-Zeiger und Arrays mit Beispielen

Traditionell greifen wir über einen Index auf Array-Elemente zu, aber auch Zeiger vereinfachen dies. Ein Zeiger, der auf den Array-Namen gesetzt ist, verweist auf das erste Element:

#include <stdio.h>
int main()
{
   int a[5] = {1, 2, 3, 4, 5};   // array initialization
   int *p;                       // pointer declaration
   p = a;                       // p points to the first element; same as &a[0]
   for (int i = 0; i < 5; i++)
   {
      printf("%d\n", *p);            // print element
      p++;                      // move to the next element
   }
   return 0;
}

Durch Addition einer Zahl zu einem Zeiger wird dieser um die entsprechende Anzahl an Elementen nach vorne verschoben. Zeigt p auf die Speicheradresse 0, so zeigt p + 1 auf die Speicheradresse 1.

C-Zeiger und Strings mit Beispielen

Ein String ist ein Array von char-Objekten, das mit einem Nullzeichen '\0' endet. Wir können Strings mithilfe von Zeigern bearbeiten:

#include <stdio.h>
#include <string.h>
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);
   p = str;                     // reset the pointer
   for (int i = 0; i < strlen(str); i++)
   {
      printf("%c\n", *p);
      p++;
   }
   return 0;
}

Eine weitere Möglichkeit, mit Zeichenketten umzugehen, besteht in der Verwendung eines Arrays von Zeigern:

#include <stdio.h>
int main()
{
   char *materials[] = {"iron", "copper", "gold"};
   for (int i = 0; i < 3; i++)
      printf("%s\n", materials[i]);
   return 0;
}

Vorteile von Zeigern in C

• Zeiger sind nützlich, um direkt auf Speicheradressen zuzugreifen.
• Sie bieten eine effiziente Möglichkeit, auf die Elemente eines Arrays zuzugreifen.
• Sie werden für die dynamische Speicherzuweisung und -freigabe verwendet.
• Sie werden verwendet, um komplexe Datenstrukturen wie verkettete Listen, Graphen und Bäume zu bilden.

Nachteile von Zeigern in C

• Zeiger sind etwas komplex zu verstehen.
• Sie können Fehler wie Segmentierungsfehler oder den Zugriff auf einen nicht vorgesehenen Speicherbereich verursachen.
• Die Zuweisung eines falschen Wertes an einen Zeiger kann zu Speicherbeschädigung führen.
• Zeiger sind auch für Speicherlecks verantwortlich, wenn Speicher nicht freigegeben wird.
• Es liegt in der Verantwortung des Programmierers, einen Zeiger sorgfältig zu handhaben.

Häufig gestellte Fragen