Linux C Programmierung Tutorial Teil 21: Zeichenzeiger, Array von Zeigern und Zeiger auf Zeiger

Das Konzept der Zeiger ist in der Tat eines der sehr wichtigen Konzepte in der C-Programmiersprache. Bis jetzt haben wir mehrere Aspekte von Zeigern in C besprochen. Darauf aufbauend werden wir in diesem Tutorial einige weitere Zeigerkonzepte diskutieren.

Zeichenzeiger, Array von Zeigern und Zeiger auf Zeiger in C

Lassen Sie uns mit Zeichenzeigern beginnen, mit den folgenden Codezeilen:

char p[] = "Ich mag HowtoForge"  
char *p = "Ich mag HowToForge"

Die erste Zeile definiert ein Array ‘p’ mit einer Größe, die der Anzahl der Zeichen in Anführungszeichen entspricht. Die nächste Zeile definiert jedoch einen Zeiger ‘p’, der auf eine Zeichenkonstante zeigt.

Der Unterschied hier ist, dass das erste ‘p’ ein Array ist, dessen Inhalte leicht geändert oder modifiziert werden können. Da der zweite ‘p’ jedoch auf eine Zeichenkonstante zeigt, können Sie die Zeicheninhalte einfach nicht ändern.

Zum Beispiel versucht das folgende Stück Code, eine Zeichenkonstante zu ändern:

#include   
  
int main()  
{  
   char *p = "Ich mag HowToForge";  
   
   p[0] = 'U';  
   
   return 0;  
}

Und hier ist die Ausgabe, die dieser Code auf meinem System erzeugt:

Segmentierungsfehler

Dieser Fehler deutet darauf hin, dass die Programmausführung abrupt beendet wurde, und das liegt daran, dass wir versucht haben, etwas zu ändern, das konstant ist.

Beachten Sie auch, dass der Zeiger ‘p’ zwar auf eine andere Zeichenkette zeigen kann, Sie jedoch die Basisadresse des Arrays ‘p’ nicht ändern können (wenn Sie sich erinnern, haben wir dies bereits in einem unserer vorherigen Tutorials besprochen).

Jetzt kommen wir zu Zeiger-Arrays. So wie Sie Integer-, Zeichen- und andere Typen von Arrays gesehen haben, kann es auch ein Array von Zeigern geben. Zum Beispiel definiert das folgende Programm ein Array ‘arr’ von Integer-Zeigern und weist ihm Werte zu.

#include   
  
int main()  
{  
 int *arr[3];  
 int a = 0, b = 1, c = 2;  
   
 arr[0] = &a;  
 arr[1] = &b;  
 arr[2] = &c;  
  
 return 0;  
}

Beachten Sie, dass die Werte, die dem Array zugewiesen werden, Adressen sind. Das liegt daran, dass ‘arr’ ein Array von Zeigern ist, und Zeiger speichern nichts anderes als Adressen. Wenn Sie nun die Werte an diesen Adressen abrufen möchten, müssen Sie den *Operator verwenden.

Das folgende Beispiel (das nichts anderes als eine Erweiterung des vorherigen Beispiels ist) zeigt dies:

#include   
  
int main()  
{  
   int *arr[3];  
   int a = 0, b = 1, c = 2;  
   
   arr[0] = &a;  
   arr[1] = &b;  
   arr[2] = &c;  
   
   for(int i=0; i < 3; i++)  
      printf("\n arr[%d] ist: %d",i,*(arr[i]));  
  
 return 0;  
}

Hier ist die Ausgabe:

arr[0] ist: 0   
arr[1] ist: 1   
arr[2] ist: 2 

Ähnlich wie bei Integer-Zeiger-Arrays (wie wir hier besprochen haben) können Sie Arrays haben, die Zeichenzeiger und mehr speichern.

Jetzt kommen wir zu Zeigern auf Zeiger. Wie wir bisher mehrfach erwähnt haben, speichert ein Zeiger eine Adresse. Bis jetzt haben wir in dieser laufenden C-Programmiertutorial-Serie nur einen Zeiger gesehen, der auf eine Nicht-Zeiger-Variable zeigt, aber die Tatsache ist, dass Zeiger auch auf andere Zeiger zeigen können.

Das bedeutet, dass ein Zeiger die Adresse eines anderen Zeigers speichern kann. Zum Beispiel ist der folgende ein Doppelzeiger oder ein Zeiger auf einen Zeiger:

int **ptr;

Hier ist ein Stück Code, das einen Doppelzeiger verwendet:

#include   
  
int main()  
{  
   int *ptr;  
   int p;  
   
   int a = 10;  
   
   ptr = &a;  
   
   p = &ptr;  
   
   printf("\n Zeiger 'p' zeigt auf Zeiger 'ptr', der weiter auf den Wert zeigt: %d", p);  
   
   return 0;  
}

Hier ist die Ausgabe:

Zeiger 'p' zeigt auf Zeiger 'ptr', der weiter auf den Wert zeigt: 10

Das war ein Beispiel für einen Doppelzeiger. In ähnlicher Weise können Sie einen Zeiger auf einen Zeiger auf einen Zeiger haben, der beispielsweise als int *ptr definiert ist. Die maximale Anzahl solcher ‘Zeiger auf Zeiger auf……’ Ebenen ist implementierungsspezifisch (in einigen Fällen liegt das Limit jedoch bei 12).

Praktisch werden Sie jedoch wahrscheinlich nur auf Zeiger auf Zeiger bis zur dritten Ebene stoßen, da mehr Ebenen die Logik komplizierter machen, um sie zu verstehen und zu warten.

Fazit

Wir haben hier drei wichtige Konzepte zu Zeigern besprochen. Es wird empfohlen, die Beispiele und Konzepte, die wir hier besprochen haben, auf Ihrem System auszuprobieren, um ein besseres Verständnis dafür zu bekommen, wie diese Dinge funktionieren. Bei Fragen oder Zweifeln hinterlassen Sie uns bitte einen Kommentar unten.