C Pointers (met voorbeelden)

In deze tutorial leer je over aanwijzingen; wat zijn de aanwijzingen, hoe gebruik je ze en de veelgemaakte fouten die je kunt tegenkomen als je ermee werkt aan de hand van voorbeelden.

Pointers zijn krachtige functies van C- en C ++ -programmering. Voordat we aanwijzingen leren, leren we adressen in C-programmering.

Adres in C

Als je een variabele var in je programma hebt, &varzal je zijn adres in het geheugen krijgen.

We hebben het adres meerdere keren gebruikt tijdens het gebruik van de scanf()functie.

 scanf("%d", &var);

Hier wordt de waarde die door de gebruiker is ingevoerd, opgeslagen in het adres van de variabele var. Laten we een werkend voorbeeld nemen.

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

Uitvoer

 var: 5 adres van var: 2686778

Opmerking: u krijgt waarschijnlijk een ander adres als u de bovenstaande code uitvoert.

C Pointers

Pointers (pointervariabelen) zijn speciale variabelen die worden gebruikt om adressen op te slaan in plaats van waarden.

Pointer-syntaxis

Hier is hoe we aanwijzingen kunnen geven.

 int* p;

Hier hebben we een pointer p van het inttype verklaard .

U kunt ook op deze manieren aanwijzingen geven.

 int *p1; int * p2;

Laten we nog een voorbeeld nemen van het aangeven van aanwijzingen.

 int* p1, p2;

Hier hebben we een pointer p1 en een normale variabele p2 gedeclareerd.

Adressen toewijzen aan Pointers

Laten we een voorbeeld nemen.

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

Hier wordt 5 toegewezen aan de variabele c. En het adres van c wordt toegewezen aan de pc-pointer.

Krijg waarde van het ding gewezen door pointers

Om de waarde van het ding door de aanwijzers aangegeven te krijgen, gebruiken we de *operator. Bijvoorbeeld:

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

Hier wordt het adres van ctoegewezen aan de pc-pointer. Om de waarde op dat adres te krijgen, gebruikten we * pc.

Opmerking: in het bovenstaande voorbeeld is de pc een aanwijzer, niet *pc. Je kunt en mag zoiets niet doen *pc = &c;

Overigens *wordt dit de dereferentie-operator genoemd (bij het werken met pointers). Het werkt op een aanwijzer en geeft de waarde weer die in die aanwijzer is opgeslagen.

Veranderende waarde aangegeven door pointers

Laten we een voorbeeld nemen.

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

We hebben het adres van c toegewezen aan de pc-pointer.

Vervolgens hebben we de waarde van c gewijzigd in 1. Aangezien pc en het adres van c hetzelfde zijn, *pckrijgen we 1.

Laten we een ander voorbeeld nemen.

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

We hebben het adres van c toegewezen aan de pc-pointer.

Daarna zijn we overgestapt *pcop 1 met *pc = 1;. Omdat pc en het adres van c hetzelfde zijn, is c gelijk aan 1.

Laten we nog een voorbeeld nemen.

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

In eerste instantie wordt het adres van c toegewezen aan de pc-aanwijzer met pc = &c;. Omdat c is 5, *pcgeeft ons 5.

Vervolgens wordt het adres van d toegewezen aan de pc-aanwijzer met pc = &d;. Aangezien d -15 is, *pcgeeft dit ons -15.

Voorbeeld: werken met pointers

Laten we een werkend voorbeeld nemen.

 #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; )

Uitvoer

 Adres van c: 2686784 Waarde van c: 22 Adres van pointer pc: 2686784 Inhoud van pointer pc: 22 Adres van pointer pc: 2686784 Inhoud van pointer pc: 11 Adres van c: 2686784 Waarde van c: 2

Toelichting op het programma

  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 beide gevallen maken we een aanwijzer p(niet *p) en wijzen &cwe deze toe.

Om deze verwarring te voorkomen, kunnen we de verklaring als volgt gebruiken:

 int* p = &c;

Nu je weet wat pointers zijn, leer je in de volgende tutorial hoe pointers gerelateerd zijn aan arrays.

Interessante artikelen...