int main () {
int my_number =10;
int *ptr; // Förklara en pekare till ett heltal
ptr =&my_number; // tilldela adressen till my_number till pekaren PTR
printf ("värde på my_number:%d \ n", my_number);
printf ("Adress till my_number:%p \ n", &my_number); // %p är formatspecifikatorn för utskriftsadresser
printf ("värde på ptr:%p \ n", ptr);
printf ("Värde pekad på av PTR:%d \ n", *ptr); // Dereferencing pekaren
return 0;
}
`` `
Utgång (kommer att variera beroende på systemet):
`` `
Värdet på my_number:10
Adress till my_number:0x7ffc94b2d8a0
Värdet på PTR:0x7ffc94b2d8a0
Värde pekas på av PTR:10
`` `
Förklaring:
1. `int my_number =10;` :Förklarar en heltalsvariabel `my_number` och initialiserar den till 10. Kompilatorn tilldelar en minnesplats för att lagra denna variabel.
2. `int *ptr;` :Förklarar en pekarvariabel `PTR 'som är utformad för att hålla adressen till en heltalvariabel.
3. `ptr =&my_number;` :Det är här adressoperatören spelar in. `&my_number` utvärderas till minnesadressen där` my_number 'lagras. Denna adress tilldelas sedan pekarvariabeln `PTR`. Nu pekar `ptr` * på *` my_number '.
4. `printf (" Adress till my_number:%p \ n ", &my_number);` :Skriver ut minnesadressen för `my_number 'med hjälp av specificeraren`%p`.
5. `printf (" värde på ptr:%p \ n ", ptr);` :Skriver ut värdet lagrat i `ptr`, som är adressen till` my_number '. Lägg märke till att adressen som skrivs ut här är densamma som adressen till `my_number '.
6. `printf (" Värde pekas på av ptr:%d \ n ", *ptr);` :Denna linje visar * Dereferencing * pekaren. Operatören `*`, när den används med en pekare, får åtkomst till värdet som lagras på minnesplatsen som pekaren pekar på. Så `*ptr` åtkomst till värdet på` my_number '(som är 10).
Vanliga användningsområden för adressoperatören:
1. pekare: Som visas ovan är adressoperatören grundläggande för att arbeta med pekare. Pointers lagrar minnesadresser och adressoperatören tillhandahåller dessa adresser.
2. Funktionssamtal med referens: C stöder funktionssamtal efter värde och efter referens. För att skicka en variabel som referens skickar du dess adress till funktionen. Funktionen kan sedan modifiera den ursprungliga variabeln med pekaren som den får.
`` `c
#include
void inkrement (int *nummer) {
(*nummer) ++; // Öka värdet på den adress som pekas på av 'Number'
}
int main () {
int x =5;
printf ("före ökning:%d \ n", x);
inkrement (&x); // överföra adressen till X till inkrementfunktionen
printf ("efter inkrement:%d \ n", x);
return 0;
}
`` `
I det här exemplet modifierar "inkrement" den ursprungliga "x" eftersom den får en pekare till "x" (dvs dess adress).
3. Dynamisk minnesallokering: När du tilldelar minne dynamiskt med hjälp av funktioner som `malloc ()`, arbetar du med pekare till det tilldelade minnet. Adressoperatören används ofta implicit när du skickar en pekare till dynamiskt tilldelat minne till funktioner.
`` `c
#include
#include
int main () {
int *arr;
int -storlek =5;
// Tilldela minne för en rad 5 heltal
arr =(int *) malloc (storlek * storlek av (int));
if (arr ==null) {
printf ("minnesallokering misslyckades! \ n");
return 1;
}
// Åtkomstelement i matrisen med pekararitmetik
för (int i =0; i
arr [i] =i * 2;
}
// Skriv ut matriselementen
för (int i =0; i
printf ("arr [ %d] =%d \ n", i, *(arr + i)); //*(arr + i) motsvarar arr [i]
}
gratis (arr); // frigör det dynamiskt tilldelade minnet
return 0;
}
`` `
`Malloc` returnerar en tomrumspekare som sedan måste kastas till lämplig datatyp,` (int*) `i detta fall. Variabeln "Arr" har nu startadressen för det tilldelade minnesblocket.
4. strukturer och fackföreningar: Du kan använda adressoperatören för att få adressen till en struktur eller facklig variabel. Detta är viktigt för att överföra strukturer till funktioner genom referens eller för att skapa pekare till strukturer.
`` `c
#include
strukturpunkt {
int x;
int y;
};
int main () {
Struct Point P ={10, 20};
Struct Point *PTR_P =&P; // Få adressen till punktstrukturen
printf ("Adress till p:%p \ n", &p);
printf ("Adress till p.x:%p \ n", &p.x); // Adressen till X -medlemmen
printf ("Adress till p.y:%p \ n", &p.y); // Adressen till Y -medlemmen
ptr_p-> x =5; // komma åt X -medlemmen med pekaren
ptr_p-> y =15; // Åtkomst till Y -medlemmen med pekaren
printf ("p.x:%d, p.y:%d \ n", p.x, p.y); // Output:P.X:5, P.Y:15
return 0;
}
`` `
Viktiga överväganden:
* l-värden: Adressoperatören kan endast tillämpas på det som kallas ett "L-värde." Ett L-värde är ett uttryck som hänvisar till en minnesplats, till exempel ett variabel, arrayelement eller ett fält i en struktur. Du kan inte tillämpa adressoperatören på en konstant eller ett tillfälligt värde som produceras av ett uttryck (t.ex. `&(5 + 3)` är ogiltig).
* Datatyp: Adressoperatören returnerar en pekare vars datatyp är datatypen för den variabel som den tillämpas på. Till exempel returnerar `&my_number '(där' my_number 'är en' int ') en' int*'.
Sammanfattningsvis är adressoperatören (`&') en grundläggande operatör i C som ger ett sätt att komma åt minnesplatsen för en variabel. Det är viktigt för pekarmanipulation, funktionssamtal efter referens, dynamisk minnesallokering och arbetar med strukturer och fackföreningar. Att förstå dess syfte och funktionalitet är avgörande för att skriva effektiva och robusta C -program.
