int main () {
int my_number =10;
int *ptr; // erklær en markør til et heltal
ptr =&my_number; // Tildel adressen på my_number til markøren PTR
printf ("Værdi af my_number:%d \ n", my_number);
printf ("adresse på my_number:%p \ n", &my_number); // %p er formatspecifikatoren til udskrivningsadresser
printf ("Værdi af ptr:%p \ n", ptr);
printf ("Værdi peget på af ptr:%d \ n", *ptr); // derferencing af markøren
return 0;
}
`` `
output (vil variere afhængigt af systemet):
`` `
Værdi af my_number:10
Adresse på my_number:0x7ffc94b2d8a0
Værdi af PTR:0x7ffc94b2d8a0
Værdi peget på af PTR:10
`` `
Forklaring:
1. `int my_number =10;` :Erklærer en heltalsvariabel `my_number` og initialiserer den til 10. Compileren tildeler en hukommelsesplacering til at gemme denne variabel.
2. `int *ptr;` :Erklærer en markørvariabel `ptr`, der er designet til at holde adressen på en heltalvariabel.
3. `ptr =&my_number;` :Det er her adresseoperatøren kommer i spil. `&my_number` evaluerer til hukommelsesadressen, hvor` my_number` er gemt. Denne adresse tildeles derefter til markørvariablen `PTR '. Nu, 'ptr` * peger på *' my_number '.
4. :Udskriver hukommelsesadressen på `my_number` ved hjælp af`%p` -formatspecifikatoren.
5. `printf (" Værdi af ptr:%p \ n ", ptr);` :Udskriver den værdi, der er gemt i `ptr`, som er adressen på` my_number '. Bemærk, at adressen, der er trykt her, er den samme som adressen på 'my_number'.
6. `printf (" Værdi peget på af ptr:%d \ n ", *ptr);` :Denne linje demonstrerer * derferencing * markøren. Operatøren `*`, når den bruges sammen med en markør, får adgang til den værdi, der er gemt på hukommelsesplaceringen, der er peget på markøren. Så `*ptr` får adgang til værdien af` my_number '(som er 10).
Almindelige anvendelser af adresseoperatøren:
1. Pegere: Som vist ovenfor er adresseoperatøren grundlæggende for at arbejde med pointers. Pegere opbevarer hukommelsesadresser, og adresseoperatøren indeholder disse adresser.
2. funktionsopkald som reference: C understøtter funktionsopkald efter værdi og som reference. For at videregive en variabel som reference videregiver du sin adresse til funktionen. Funktionen kan derefter ændre den originale variabel ved hjælp af markøren, den modtager.
`` c
#include
ugyldigt stigning (int *nummer) {
(*nummer) ++; // øg værdien på den adresse, der er peget på med 'nummer'
}
int main () {
int x =5;
printf ("Før forøgelse:%d \ n", x);
øget (&x); // Send adressen på X til forøgelsesfunktionen
printf ("Efter stigning:%d \ n", x);
return 0;
}
`` `
I dette eksempel ændrer `increment 'den originale` x', fordi den modtager en markør til `x '(dvs. dens adresse).
3. dynamisk hukommelsesallokering: Når du tildeler hukommelse dynamisk ved hjælp af funktioner som `malloc ()`, arbejder du med pointer til den tildelte hukommelse. Adresseoperatøren bruges ofte implicit, når du videregiver en markør til dynamisk tildelt hukommelse til funktioner.
`` c
#include
#include
int main () {
int *arr;
int størrelse =5;
// Tildel hukommelse til en række 5 heltal
arr =(int *) malloc (størrelse * størrelse af (int));
if (arr ==null) {
printf ("hukommelsesallokering mislykkedes! \ n");
retur 1;
}
// Adgangselementer i matrixen ved hjælp af markørens aritmetik
for (int i =0; i
arr [i] =i * 2;
}
// Udskriv array -elementerne
for (int i =0; i
printf ("arr [ %d] =%d \ n", i, *(arr + i)); //*(arr + i) svarer til arr [i]
}
gratis (arr); // frigør den dynamisk tildelte hukommelse
return 0;
}
`` `
`Malloc` returnerer en tomrums -markør, som derefter skal kastes til den relevante datatype,` (int*) `I dette tilfælde. Variablen 'ARR` har nu startadressen for den tildelte hukommelsesblok.
4. strukturer og fagforeninger: Du kan bruge adresseoperatøren til at få adressen på en struktur- eller fagforeningsvariabel. Dette er vigtigt for at videregive strukturer til funktioner som reference eller for at skabe pointer til strukturer.
`` c
#include
struct punkt {
int x;
int y;
};
int main () {
struct punkt p ={10, 20};
struct punkt *ptr_p =&p; // Få adressen på punktstrukturen
printf ("adresse på p:%p \ n", &p);
printf ("Adresse til p.x:%p \ n", &p.x); // Adresse på X -medlemmet
printf ("adresse til P.Y:%p \ n", &p.y); // Adressen på Y -medlemmet
ptr_p-> x =5; // få adgang til X -medlemmet ved hjælp af markøren
ptr_p-> y =15; // få adgang til Y -medlemmet ved hjælp af markøren
printf ("p.x:%d, p.y:%d \ n", p.x, p.y); // output:p.x:5, p.y:15
return 0;
}
`` `
Vigtige overvejelser:
* l-værdier: Adresseoperatøren kan kun anvendes på det, der kaldes en "L-værdi." En L-værdi er et udtryk, der henviser til en hukommelsesplacering, såsom en variabel, arrayelement eller et felt inden for en struktur. Du kan ikke anvende adresseoperatøren på en konstant eller en midlertidig værdi produceret af et udtryk (f.eks. `&(5 + 3)` er ugyldig).
* Datatype: Adresseoperatøren returnerer en markør, hvis datatype er datatypen for den variabel, den anvendes til. For eksempel returnerer `&my_number` (hvor` my_number` er en `int`) en` int*`.
Sammenfattende er adresseoperatøren (`&`) en grundlæggende operatør i C, der giver en måde at få adgang til hukommelsesplaceringen af en variabel. Det er vigtigt for markørmanipulation, funktionsopkald som reference, dynamisk hukommelsesallokering og arbejde med strukturer og fagforeninger. At forstå dens formål og funktionalitet er afgørende for at skrive effektive og robuste C -programmer.
