** in C

1. Speicherzuweisung für Variable in C
2. C-Zeiger
3. Zeiger auf Zeiger (**) in C

Dieses Tutorial lehrt, wie man den Pointer to Pointer (Doppelzeiger oder ** ) verwendet, um die Adresse einer anderen Zeigervariable zu speichern.

Speicherzuweisung für Variable in C

Beim Erstellen einer Variablen wird dieser Variablen ein bestimmter Speicherblock zum Speichern des Werts zugewiesen. Zum Beispiel haben wir eine char-Variable ch und den Wert a erstellt. Intern wird der Variablen ch ein Byte Speicherplatz zugewiesen.

C-Zeiger

In der C-Programmierung ist ein Zeiger eine Variable, die die Adresse einer anderen Variablen speichert. Um auf den in dieser Adresse vorhandenen Wert zuzugreifen, verwenden wir *.

#include <stdio.h>

int main() {
  char ch = 'a';    // create a variable
  char *ptr = &ch;  // create a pointer to store the address of ch

  printf("Address of ch: %p\n", &ch);  // prints address
  printf("Value of ch: %c\n", ch);     // prints 'a'

  printf("\nValue of ptr: %p\n", ptr);  // prints the address of a
  printf("*ptr(value of ch): %c\n",
         *ptr);  // Prints Content of the value of the ptr
}

Ausgabe:

Address of ch: 0x7ffc2aa264ef
Value of ch: a

Value of ptr: 0x7ffc2aa264ef
*ptr(value of ch): a

Im obigen Code,

• Eine char-Variable ch erstellt und als Wert das Zeichen a zugewiesen.
• Erstellt einen char-Zeiger ptr und speichert die Adresse der Variablen ch.
• Adresse und Wert von ch aufgedruckt.
• Wert von ptr gedruckt, der Wert von ptr ist die Adresse von ch
• Druckt den Wert von ch mit *ptr. Der Wert von ptr ist die Adresse der Variablen ch, in dieser Adresse ist der Wert 'a' vorhanden, also wird er gedruckt.

Zeiger auf Zeiger (**) in C

Um die Adresse einer Variablen zu speichern, verwenden wir einen Zeiger. Um die Adresse eines Zeigers zu speichern, müssen wir in ähnlicher Weise ** (pointer to pointer) verwenden. ** bezeichnet einen Zeiger, der die Adresse eines anderen Zeigers speichert.

Um den in der Zeiger-zu-Zeiger-Variablen vorhandenen Wert zu drucken, müssen wir ** verwenden.

#include <stdio.h>

int main() {
  char ch = 'a';           // create a variable
  char *ptr = &ch;         // create a pointer to store the address of ch
  char **ptrToPtr = &ptr;  // create a pointer to store the address of ch

  printf("Address of ch: %p\n", &ch);  // prints address of ch
  printf("Value of ch: %c\n", ch);     // prints 'a'

  printf("\nValue of ptr: %p\n", ptr);   // prints the address of ch
  printf("Address of ptr: %p\n", &ptr);  // prints address

  printf("\nValue of ptrToPtr: %p\n", ptrToPtr);  // prints the address of ptr
  printf("*ptrToPtr(Address of ch): %p\n",
         *ptrToPtr);  // prints the address of ch
  printf("**ptrToPtr(Value of ch): %c\n", **ptrToPtr);  // prints ch
}

Ausgabe:

Address of ch: 0x7fffb48f95b7
Value of ch: a

Value of ptr: 0x7fffb48f95b7
Address of ptr: 0x7fffb48f95b8

Value of ptrToPtr: 0x7fffb48f95b8
*ptrToPtr(Address of ch): 0x7fffb48f95b7
**ptrToPtr(Value of ch): a

Im obigen Code,

• Eine char-Variable ch erstellt und ihr das Zeichen a als Wert zugewiesen.
• Erstellt einen char-Zeiger ptr und speichert die Adresse der Variablen ch.
• Erstellt einen char-Zeiger auf den Zeiger ptrToPtr und speichert die Adresse der Variablen ptr.
• Der ptr hat die Adresse der Variablen ch als Wert, und der ptrToPtr hat die Adresse des Zeigers ptr als Wert.
• Wenn wir ptrToPtr wie *ptrToPtr dereferenzieren, erhalten wir die Adresse der Variablen ch
• Wenn wir ptrToPtr wie **ptrToPtr dereferenzieren, erhalten wir den Wert der Variablen ch

Punkt zum Erinnern

Um die Adresse von ptrToPtr zu speichern, müssen wir erstellen

char ***ptrToPtrToPtr = &ptrToPtr;
printf("***ptrToPtrToPtr : %c\n", ***ptrToPtrToPtr);  // 'a'