int hoofd() {
int mijn_nummer =10;
int *ptr; // Declareer een pointer naar een geheel getal
ptr =&mijn_nummer; // Wijs het adres van mijn_nummer toe aan de pointer ptr
printf("Waarde van mijn_nummer:%d\n", mijn_nummer);
printf("Adres van mijn_nummer:%p\n", &mijn_nummer); // %p is de formaatspecificatie voor het afdrukken van adressen
printf("Waarde van ptr:%p\n", ptr);
printf("Waarde waarnaar ptr verwijst:%d\n", *ptr); // De verwijzing naar de aanwijzer ongedaan maken
retour 0;
}
```
Uitvoer (varieert afhankelijk van het systeem):
```
Waarde van mijn_nummer:10
Adres van mijn_nummer:0x7ffc94b2d8a0
Waarde van ptr:0x7ffc94b2d8a0
Waarde aangegeven door ptr:10
```
Uitleg:
1. `int mijn_nummer =10;` :Declareert een geheel getalvariabele `mijn_getal` en initialiseert deze op 10. De compiler wijst een geheugenlocatie toe om deze variabele op te slaan.
2. `int *ptr;` :Declareert een pointervariabele `ptr` die is ontworpen om het adres van een integer-variabele te bevatten.
3. `ptr =&mijn_nummer;` :Dit is waar de adresoperator in het spel komt. `&mijn_nummer` resulteert in het geheugenadres waar `mijn_nummer` is opgeslagen. Dit adres wordt vervolgens toegewezen aan de pointervariabele `ptr`. Nu, `ptr` *wijst naar* `mijn_nummer`.
4. `printf("Adres van mijn_nummer:%p\n", &mijn_nummer);` :Drukt het geheugenadres van `mijn_nummer` af met behulp van de `%p` formaatspecificatie.
5. `printf("Waarde van ptr:%p\n", ptr);` :Drukt de waarde af die is opgeslagen in `ptr`, wat het adres is van `mijn_nummer`. Merk op dat het hier afgedrukte adres hetzelfde is als het adres van `mijn_nummer`.
6. `printf("Waarde waarnaar ptr verwijst:%d\n", *ptr);` :Deze regel demonstreert het *derefereren* van de aanwijzer. De `*`-operator heeft, indien gebruikt met een pointer, toegang tot de waarde die is opgeslagen op de geheugenlocatie waarnaar de pointer verwijst. Dus `*ptr` heeft toegang tot de waarde van `mijn_nummer` (wat 10 is).
Gemeenschappelijk gebruik van de adresoperator:
1. Aanwijzingen: Zoals hierboven weergegeven, is de adresoperator van fundamenteel belang voor het werken met pointers. Pointers slaan geheugenadressen op en de adresoperator levert die adressen.
2. Functieoproepen per referentie: C ondersteunt functieaanroepen op waarde en op referentie. Om een variabele door te geven als referentie, geeft u het adres door aan de functie. De functie kan vervolgens de oorspronkelijke variabele wijzigen met behulp van de ontvangen aanwijzer.
```c
#include
ongeldige toename(int *getal) {
(*nummer)++; // Verhoog de waarde op het adres waarnaar 'getal' verwijst
}
int hoofd() {
intx =5;
printf("Vóór verhoging:%d\n", x);
verhoging(&x); // Geef het adres van x door aan de incrementfunctie
printf("Na verhoging:%d\n", x);
retour 0;
}
```
In dit voorbeeld wijzigt 'increment' de originele 'x' omdat het een verwijzing naar 'x' ontvangt (d.w.z. het adres ervan).
3. Dynamische geheugentoewijzing: Wanneer u geheugen dynamisch toewijst met behulp van functies als `malloc()`, werkt u met verwijzingen naar het toegewezen geheugen. De adresoperator wordt vaak impliciet gebruikt wanneer u een verwijzing doorgeeft naar dynamisch toegewezen geheugen aan functies.
```c
#include
#include
int hoofd() {
int *arr;
int-grootte =5;
// Wijs geheugen toe voor een array van 5 gehele getallen
arr =(int*)malloc(grootte * groottevan(int));
als (arr ==NULL) {
printf("Geheugentoewijzing mislukt!\n");
retour 1;
}
// Krijg toegang tot elementen van de array met behulp van pointer-berekeningen
voor (int i =0; i
arr[i] =ik * 2;
}
// Druk de array-elementen af
voor (int i =0; i
printf("arr[%d] =%d\n", i, *(arr + i)); //*(arr + i) is gelijk aan arr[i]
}
gratis(arr); // Maak het dynamisch toegewezen geheugen vrij
retour 0;
}
```
`malloc` retourneert een lege pointer die vervolgens naar het juiste gegevenstype moet worden gecast, in dit geval `(int*)`. De variabele `arr` bevat nu het startadres van het toegewezen geheugenblok.
4. Structuren en vakbonden: U kunt de adresoperator gebruiken om het adres van een structuur- of unievariabele te verkrijgen. Dit is essentieel voor het doorgeven van structuren aan functies door middel van verwijzing of voor het creëren van verwijzingen naar structuren.
```c
#include
struct Punt {
int x;
int y;
};
int hoofd() {
struct Punt p ={10, 20};
struct Punt *ptr_p =&p; // Haal het adres van de puntstructuur op
printf("Adres van p:%p\n", &p);
printf("Adres van p.x:%p\n", &p.x); // Adres van het x-lid
printf("Adres van p.y:%p\n", &p.y); // Adres van het y-lid
ptr_p->x =5; // Krijg toegang tot het x-lid met behulp van de aanwijzer
ptr_p->y =15; // Ga naar het y-lid met behulp van de aanwijzer
printf("p.x:%d, p.y:%d\n", p.x, p.y); // Uitgang:p.x:5, p.y:15
retour 0;
}
```
Belangrijke overwegingen:
* L-waarden: De adresoperator kan alleen worden toegepast op wat een 'l-waarde' wordt genoemd. Een l-waarde is een uitdrukking die verwijst naar een geheugenlocatie, zoals een variabele, een array-element of een veld binnen een structuur. U kunt de adresoperator niet toepassen op een constante of tijdelijke waarde die door een expressie wordt geproduceerd (bijvoorbeeld:`&(5 + 3)` is ongeldig).
* Gegevenstype: De adresoperator retourneert een aanwijzer waarvan het gegevenstype het gegevenstype is van de variabele waarop deze wordt toegepast. `&mijn_nummer` (waarbij `mijn_nummer` een `int` is) retourneert bijvoorbeeld een `int*`.
Samenvattend is de adresoperator (`&`) een fundamentele operator in C die een manier biedt om toegang te krijgen tot de geheugenlocatie van een variabele. Het is essentieel voor pointermanipulatie, functieaanroepen door middel van referentie, dynamische geheugentoewijzing en het werken met structuren en vakbonden. Het begrijpen van het doel en de functionaliteit ervan is cruciaal voor het schrijven van efficiënte en robuuste C-programma's.
