C-Zeiger (mit Beispielen)

In diesem Tutorial lernen Sie Zeiger kennen. Was sind Zeiger, wie verwenden Sie sie und die häufigsten Fehler, die bei der Arbeit mit ihnen anhand von Beispielen auftreten können?

Zeiger sind leistungsstarke Funktionen der C- und C ++ - Programmierung. Bevor wir Zeiger lernen, lernen wir die Adressen in der C-Programmierung kennen.

Adresse in C.

Wenn Sie eine Variable var in Ihrem Programm haben, erhalten &varSie deren Adresse im Speicher.

Wir haben die Adresse bei der Verwendung der scanf()Funktion mehrfach verwendet.

 scanf("%d", &var);

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

 #include int main() ( int var = 5; printf("var: %d", var); // Notice the use of & before var printf("address of var: %p", &var); return 0; )

Ausgabe

 var: 5 Adresse von var: 2686778

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

C Zeiger

Zeiger (Zeigervariablen) sind spezielle Variablen, die zum Speichern von Adressen anstelle von Werten verwendet werden.

Zeigersyntax

So können wir Zeiger deklarieren.

 int* p;

Hier haben wir einen Zeiger p vom intTyp deklariert .

Auf diese Weise können Sie auch Zeiger deklarieren.

 int *p1; int * p2;

Nehmen wir ein weiteres Beispiel für die Deklaration von Zeigern.

 int* p1, p2;

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

Zuweisen von Adressen zu Zeigern

Nehmen wir ein Beispiel.

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

Hier ist der Variablen c 5 zugeordnet. Und die Adresse von c wird dem PC-Zeiger zugewiesen.

Holen Sie sich den Wert der Sache, auf die Zeiger zeigen

Um den Wert der Sache zu erhalten, auf die die Zeiger zeigen, verwenden wir den *Operator. Beispielsweise:

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

Hier wird die Adresse von cdem PC-Zeiger zugewiesen. Um den in dieser Adresse gespeicherten Wert zu erhalten, haben wir * pc verwendet.

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

Wird übrigens *der Dereferenzierungsoperator genannt (bei der Arbeit mit Zeigern). Es arbeitet mit einem Zeiger und gibt den in diesem Zeiger gespeicherten Wert an.

Ändern des durch Zeiger angezeigten Werts

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 dem PC-Zeiger die Adresse c zugewiesen.

Dann haben wir den Wert von c auf 1 geändert. Da pc und die Adresse von c gleich sind, erhalten *pcwir 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 dem PC-Zeiger die Adresse c zugewiesen.

Then, we changed *pc to 1 using *pc = 1;. Since pc and the address of c is the same, c will be equal to 1.

Let's take one more example.

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

Initially, the address of c is assigned to the pc pointer using pc = &c;. Since c is 5, *pc gives us 5.

Then, the address of d is assigned to the pc pointer using pc = &d;. Since d is -15, *pc gives us -15.

Example: Working of Pointers

Let's take a working example.

 #include int main() ( int* pc, c; c = 22; printf("Address of c: %p", &c); printf("Value of c: %d", c); // 22 pc = &c; printf("Address of pointer pc: %p", pc); printf("Content of pointer pc: %d", *pc); // 22 c = 11; printf("Address of pointer pc: %p", pc); printf("Content of pointer pc: %d", *pc); // 11 *pc = 2; printf("Address of c: %p", &c); printf("Value of c: %d", c); // 2 return 0; )

Output

 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

Explanation of the program

  1. int* pc, c;

    Here, a pointer pc and a normal variable c, both of type int, is created.
    Since pc and c are not initialized at initially, pointer pc points to either no address or a random address. And, variable c has an address but contains random garbage value.
  2. c = 22;

    This assigns 22 to the variable c. That is, 22 is stored in the memory location of variable c.
  3. pc = &c;

    This assigns the address of variable c to the pointer pc.
  4. c = 11;

    This assigns 11 to variable c.
  5. *pc = 2;

    This change the value at the memory location pointed by the pointer pc to 2.

Common mistakes when working with pointers

Suppose, you want pointer pc to point to the address of c. Then,

 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; // both c and *pc values *pc = c;

Here's an example of pointer syntax beginners often find confusing.

 #include int main() ( int c = 5; int *p = &c; printf("%d", *p); // 5 return 0; )

Why didn't we get an error when using int *p = &c;?

It's because

 int *p = &c;

is equivalent to

 int *p: p = &c;

In beiden Fällen erstellen wir einen Zeiger p(nicht *p) und weisen &cihn zu.

Um diese Verwirrung zu vermeiden, können wir die folgende Aussage verwenden:

 int* p = &c;

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

Interessante Beiträge...