C-aanwijzers

In deze tutorial leer je over pointers; wat zijn pointers, hoe gebruik je ze en de veelvoorkomende fouten die je tegen kunt komen als je ermee werkt aan de hand van voorbeelden.

Aanwijzers zijn krachtige functies van C- en C++-programmering. Laten we, voordat we pointers leren, eerst iets leren over adressen in C-programmering.

Adres in C

Als je een variabele var . hebt in je programma, &var zal je het adres in het geheugen geven.

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

scanf("%d", &var);

Hier wordt de door de gebruiker ingevoerde waarde opgeslagen in het adres van var variabel. Laten we een werkend voorbeeld nemen.

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

Uitvoer

var: 5 
address of var: 2686778

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

C-aanwijzers

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

Aanwijzersyntaxis

Hier is hoe we pointers kunnen declareren.

int* p;

Hier hebben we een pointer p . gedeclareerd van int typ.

U kunt op deze manieren ook pointers declareren.

int *p1;
int * p2;

Laten we nog een voorbeeld nemen van het declareren van pointers.

int* p1, p2;

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

Adressen toewijzen aan Pointers

Laten we een voorbeeld nemen.

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

Hier wordt 5 toegewezen aan de c variabel. En, het adres van c is toegewezen aan de pc aanwijzer.

Krijg waarde van dingen die door aanwijzers worden gewezen

Om de waarde te krijgen van het ding dat door de pointers wordt aangeduid, gebruiken we de * exploitant. Bijvoorbeeld:

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

Hier het adres van c is toegewezen aan de pc wijzer. Om de waarde op dat adres te krijgen, gebruikten we *pc .

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

Trouwens, * wordt de dereferentie-operator genoemd (bij het werken met aanwijzers). Het werkt op een aanwijzer en geeft de waarde die in die aanwijzer is opgeslagen.

Waarde wijzigen die wordt aangegeven door aanwijzers

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 naar de pc aanwijzer.

Vervolgens hebben we de waarde van c . gewijzigd naar 1. Sinds pc en het adres van c is hetzelfde, *pc geeft ons 1.

Laten we nog een 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 naar de pc aanwijzer.

Daarna hebben we *pc . gewijzigd naar 1 met *pc = 1; . Sinds pc en het adres van c is hetzelfde, c zal gelijk zijn 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

Aanvankelijk was het adres van c is toegewezen aan de pc aanwijzer met pc = &c; . Sinds c is 5, *pc geeft ons 5.

Dan, het adres van d is toegewezen aan de pc aanwijzer met pc = &d; . Sinds d is -15, *pc geeft ons -15.

Voorbeeld:werking van aanwijzers

Laten we een werkend voorbeeld nemen.

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

Uitvoer

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

Uitleg van het programma

1. int* pc, c;
   
   Hier, een pointer pc en een normale variabele c , beide van het type int , is gecreëerd.
   Sinds pc en c zijn aanvankelijk niet geïnitialiseerd, pointer pc verwijst naar ofwel geen adres of een willekeurig adres. En, variabele c heeft een adres maar bevat willekeurige afvalwaarde.
   
2. c = 22;
   
   Dit wijst 22 toe aan de variabele c . Dat wil zeggen, 22 wordt opgeslagen in de geheugenlocatie van variabele c .
   
3. pc = &c;
   
   Dit wijst het adres toe van variabele c naar de aanwijzer pc .
   
4. c = 11;
   
   Dit wijst 11 toe aan variabele c .
   
5. *pc = 2;
   
   Dit verandert de waarde op de geheugenlocatie die wordt aangegeven door de aanwijzer pc naar 2.

Veelgemaakte fouten bij het werken met pointers

Stel dat u de aanwijzer pc . wilt om naar het adres van c te wijzen . Dan,

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 is een voorbeeld van syntaxis van aanwijzers die beginners vaak verwarrend vinden.

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

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

Waarom hebben we geen foutmelding gekregen bij het gebruik van int *p = &c; ?

Het is omdat

int *p = &c;

is gelijk aan

int *p:
p = &c;

In beide gevallen maken we een pointer p (niet *p ) en het toewijzen van &c ernaartoe.

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.