C-Zeiger

In diesem Tutorial lernen Sie Zeiger kennen; was Zeiger sind, wie Sie sie verwenden und auf welche häufigen Fehler Sie stoßen könnten, wenn Sie mit ihnen arbeiten, anhand von Beispielen.

Zeiger sind leistungsstarke Funktionen der C- und C++-Programmierung. Bevor wir Zeiger lernen, lassen Sie uns etwas über Adressen in der C-Programmierung lernen.

Adresse in C

Wenn Sie eine Variable var haben in Ihrem Programm &var wird Ihnen seine Adresse im Speicher geben.

Wir haben die Adresse mehrfach verwendet, während wir den scanf() verwendet haben Funktion.

scanf("%d", &var);

Hier wird der vom Benutzer eingegebene Wert in der Adresse von var gespeichert Variable. Nehmen wir ein funktionierendes Beispiel.

#include <stdio.h>
int main()
{
  int var = 5;
  printf("var: %d\n", var);

  // Notice the use of & before var
  printf("address of var: %p", &var);  
  return 0;
}

Ausgabe

var: 5 
address of var: 2686778

Hinweis: Sie erhalten wahrscheinlich eine andere Adresse, wenn Sie den obigen Code ausführen.

C-Zeiger

Pointer (Pointer-Variablen) sind spezielle Variablen, die zum Speichern von Adressen und nicht von Werten verwendet werden.

Zeigersyntax

So können wir Zeiger deklarieren.

int* p;

Hier haben wir einen Zeiger p deklariert von int Typ.

Sie können Zeiger auch auf diese Weise deklarieren.

int *p1;
int * p2;

Nehmen wir ein weiteres Beispiel für das Deklarieren von Zeigern.

int* p1, p2;

Hier haben wir einen Zeiger p1 deklariert und eine normale Variable p2 .

Adressen Zeigern zuweisen

Nehmen wir ein Beispiel.

int* pc, c;
c = 5;
pc = &c;

Hier wird 5 dem c zugewiesen Variable. Und die Adresse von c ist dem PC zugewiesen Zeiger.

Get Value of Thing Pointed by Pointers

Um den Wert des Dings zu erhalten, auf das die Zeiger zeigen, verwenden wir den * Operator. Zum Beispiel:

int* pc, c;
c = 5;
pc = &c;
printf("%d", *pc);   // Output: 5

Hier die Adresse von c ist dem PC zugewiesen Zeiger. Um den in dieser Adresse gespeicherten Wert zu erhalten, haben wir *pc verwendet .

Hinweis: Im obigen Beispiel pc ist ein Zeiger, nicht *pc . Sie können und sollten so etwas wie *pc = &c nicht tun;

Übrigens * wird Dereferenzierungsoperator genannt (wenn mit Zeigern gearbeitet wird). Es arbeitet mit einem Zeiger und gibt den in diesem Zeiger gespeicherten Wert aus.

Ändern des Werts, auf den durch Zeiger verwiesen wird

Nehmen wir ein Beispiel.

int* pc, c;
c = 5;
pc = &c;
c = 1;
printf("%d", c);    // Output: 1
printf("%d", *pc);  // Ouptut: 1

Wir haben die Adresse c vergeben zum PC Zeiger.

Dann haben wir den Wert von c geändert zu 1. Seit pc und die Adresse von c ist dasselbe, *pc gibt uns 1.

Nehmen wir ein anderes Beispiel.

int* pc, c;
c = 5;
pc = &c;
*pc = 1;
printf("%d", *pc);  // Ouptut: 1
printf("%d", c);    // Output: 1

Wir haben die Adresse c vergeben zum PC Zeiger.

Dann haben wir *pc geändert auf 1 mit *pc = 1; . Seit pc und die Adresse von c ist dasselbe, c gleich 1 sein.

Nehmen wir ein weiteres Beispiel.

int* pc, c, d;
c = 5;
d = -15;

pc = &c; printf("%d", *pc); // Output: 5
pc = &d; printf("%d", *pc); // Ouptut: -15

Anfänglich die Adresse von c ist dem PC zugewiesen Zeiger mit pc = &c; . Seit c ist 5, *pc gibt uns 5.

Dann die Adresse von d ist dem PC zugewiesen Zeiger mit pc = &d; . Seit d ist -15, *pc gibt uns -15.

Beispiel:Arbeiten mit Zeigern

Nehmen wir ein funktionierendes Beispiel.

#include <stdio.h>
int main()
{
   int* pc, c;
   
   c = 22;
   printf("Address of c: %p\n", &c);
   printf("Value of c: %d\n\n", c);  // 22
   
   pc = &c;
   printf("Address of pointer pc: %p\n", pc);
   printf("Content of pointer pc: %d\n\n", *pc); // 22
   
   c = 11;
   printf("Address of pointer pc: %p\n", pc);
   printf("Content of pointer pc: %d\n\n", *pc); // 11
   
   *pc = 2;
   printf("Address of c: %p\n", &c);
   printf("Value of c: %d\n\n", c); // 2
   return 0;
}

Ausgabe

Address of c: 2686784
Value of c: 22

Address of pointer pc: 2686784
Content of pointer pc: 22

Address of pointer pc: 2686784
Content of pointer pc: 11

Address of c: 2686784
Value of c: 2

Erläuterung des Programms

int* pc, c;

Hier ein Zeiger pc und eine normale Variable c , beide vom Typ int , geschaffen.
Seit pc und c werden zunächst nicht initialisiert, Zeiger pc zeigt entweder auf keine Adresse oder eine zufällige Adresse. Und Variable c hat eine Adresse, enthält aber einen zufälligen Garbage-Wert.
c = 22;

Dies weist der Variablen c 22 zu . Das heißt, 22 wird an der Speicherstelle der Variablen c gespeichert .
pc = &c;

Dies weist die Adresse der Variablen c zu zum Zeiger pc .
c = 11;

Dies weist der Variablen c 11 zu .
*pc = 2;

Dies ändert den Wert an der Speicherstelle, auf die der Zeiger pc zeigt bis 2.

Häufige Fehler beim Arbeiten mit Zeigern

Angenommen, Sie wollen den Zeiger pc auf die Adresse von c zeigen . Dann

int c, *pc;

// pc is address but c is not
pc = c;  // Error

// &c is address but *pc is not
*pc = &c;  // Error

// both &c and pc are addresses
pc = &c;  // Not an error

// both c and *pc values 
*pc = c;  // Not an error

Hier ist ein Beispiel für Zeigersyntax, die Anfänger oft verwirrend finden.

#include <stdio.h>
int main() {
   int c = 5;
   int *p = &c;

   printf("%d", *p);  // 5
   return 0; 
}

Warum haben wir bei der Verwendung von int *p = &c; keinen Fehler erhalten ?

Das liegt daran

int *p = &c;

entspricht

int *p:
p = &c;

In beiden Fällen erstellen wir einen Zeiger p (nicht *p ) und Zuweisen von &c dazu.

Um diese Verwirrung zu vermeiden, können wir die Anweisung wie folgt verwenden:

int* p = &c;

Nachdem Sie nun wissen, was Zeiger sind, erfahren Sie im nächsten Tutorial, wie Zeiger mit Arrays zusammenhängen.

Übergeben Sie Arrays an eine Funktion in C Beziehung zwischen Arrays und Zeigern

C Sprache