Aký je účel a funkčnosť operátora adries v C?

Účel a funkčnosť operátora adries (&) v C

V C, operátor adresy (`&`) je operátor Unary, ktorý poskytuje adresu pamäť premennej alebo objektu. Je to základný nástroj na prácu s ukazovateľmi, dynamickým rozdelením pamäte a volaniami funkcií odkazom.

Účel:

Hlavným účelom operátora adries je:

* Získajte umiestnenie pamäte: Umožňuje vám načítať fyzickú adresu v pamäti, kde sa ukladá premenná. To je rozhodujúce pre manipuláciu s ukazovateľom a pochopenie toho, ako sa ukladajú premenné.

Funkcia:

Operátor `&`, keď sa použije na premennú, vráti adresu tejto premennej . Táto adresa je umiestnením pamäte predstavované hexadecimálnym číslom (napr. `0x7FFC94B2D8A0`).

Príklad:

`` C

#include

int main () {

int my_number =10;

int *ptr; // Vyhlasujte ukazovateľ na celé číslo

ptr =&my_number; // Priraďte adresu my_number k ukazovateľovi PTR

printf ("Hodnota my_number:%d \ n", my_number);

printf ("Adresa my_number:%p \ n", &my_number); // %p je špecifikátor formátu pre tlačové adresy

printf ("Hodnota ptr:%p \ n", ptr);

printf ("Hodnota poukazovaná na ptr:%d \ n", *ptr); // Dereferencie ukazovateľa

návrat 0;

}

`` `

výstup (bude sa líšiť v závislosti od systému):

`` `

Hodnota my_number:10

Adresa my_number:0x7ffc94b2d8a0

Hodnota PTR:0x7ffc94b2d8a0

Hodnota určená na PTR:10

`` `

Vysvetlenie:

1. `int my_number =10;` :Deklaruje celočíselnú premennú `my_number` a inicializuje ju na 10. Kompilátor prideľuje umiestnenie pamäte na uloženie tejto premennej.

2. `int *ptr;` :Deklaruje premennú ukazovateľa `ptr`, ktorá je navrhnutá tak, aby držala adresu celočíselnej premennej.

3. `ptr =&my_number;` :Tu prichádza do hry operátor adresy. `&my_number` hodnotí na adresu pamäte, kde sa ukladá` my_number`. Táto adresa je potom priradená premennej ukazovateľa `ptr`. Teraz `ptr` * poukazuje na *` my_number`.

4. `printf (" Adresa my_number:%p \ n ", &my_number);` :Vytlačí adresu pamäte `my_number` pomocou špecifikátora formátu`%P`.

5. `printf (" Hodnota ptr:%p \ n ", ptr); :Vytlačí hodnotu uloženú v `ptr`, čo je adresa` my_number`. Všimnite si, že tu vytlačená adresa je rovnaká ako adresa `my_number`.

6. :Tento riadok demonštruje * dereferencie * ukazovateľ. Operátor `*`, keď sa používa s ukazovateľom, pristupuje k hodnote uloženej na umiestnení pamäte, na ktorú smeruje ukazovateľ. Takže `*ptr` pristupuje k hodnote` my_number` (čo je 10).

Bežné použitie operátora adresy:

1. ukazovatele: Ako je uvedené vyššie, prevádzkovateľ adresy je základom práce s ukazovateľmi. Ukazovatele ukladajú pamäťové adresy a operátor adresy tieto adresy poskytuje.

2. C podporuje volania funkcií podľa hodnoty a odkazom. Ak chcete odovzdať premennú odkazom, odovzdáte jej adresu funkcii. Funkcia potom môže upraviť pôvodnú premennú pomocou ukazovateľa, ktorý prijíma.

`` C

#include

void increment (int *number) {

(*číslo) ++; // Zvýšenie hodnoty na adrese, na ktorú je uvedená „číslo“

}

int main () {

int x =5;

printf ("Pred prírastkom:%d \ n", x);

prírastok (&x); // odovzdajte adresu x do funkcie prírastku

printf ("po prírastku:%d \ n", x);

návrat 0;

}

`` `

V tomto príklade `inkrement` modifikuje originálny` x`, pretože prijíma ukazovateľ na `x` (t. J. Jeho adresa).

3. Dynamické pridelenie pamäte: Keď dynamicky prideľujete pamäť pomocou funkcií ako `Malloc ()`, pracujete s ukazovateľmi pridelenej pamäte. Operátor adresy sa často používa implicitne, keď odovzdáte ukazovateľ na dynamicky pridelenú pamäť na funkcie.

`` C

#include

#include

int main () {

int *arr;

Veľkosť int =5;

// prideliť pamäť pre celý rad celých čísel

arr =(int *) Malloc (veľkosť * veľkosť (int));

if (arr ==null) {

printf („Pridelenie pamäte zlyhalo! \ n“);

návrat 1;

}

// prístupové prvky poľa pomocou aritmetiky ukazovateľa

pre (int i =0; i arr [i] =i * 2;

}

// Vytlačte prvky poľa

pre (int i =0; i printf ("arr [ %d] =%d \ n", i, *(arr + i)); //*(arr + i) je rovnocenné s ARR [i]

}

zadarmo (arr); // uvoľnite dynamicky pridelenú pamäť

návrat 0;

}

`` `

`Malloc` Vráti neplatný ukazovateľ, ktorý potom musí byť obsadený do príslušného typu údajov,` (int*) `V tomto prípade. Premenná `arr` teraz drží počiatočnú adresu prideleného pamätného bloku.

4. štruktúry a odbory: Pomocou operátora adresy môžete získať adresu štruktúry alebo premennej Únie. To je nevyhnutné pre odovzdávanie štruktúr, aby fungovali odkazom alebo na vytváranie ukazovateľov na štruktúry.

`` C

#include

štruktúrový bod {

int x;

int y;

};

int main () {

struct bod p ={10, 20};

Struct Point *ptr_p =&p; // Získajte adresu štruktúry bodu

printf ("Adresa p:%p \ n", &p);

printf ("Adresa P.X:%p \ n", &p.x); // Adresa člena X

printf ("Adresa P.Y:%p \ n", &p.y); // Adresa člena Y

ptr_p-> x =5; // prístup k členovi X pomocou ukazovateľa

ptr_p-> y =15; // Prístup k členovi y pomocou ukazovateľa

printf ("P.x:%d, P.Y:%d \ n", P.X, P.Y); // Výstup:P.X:5, P.Y:15

návrat 0;

}

`` `

Dôležité úvahy:

* l-hodnoty: Prevádzkovateľ adresy je možné použiť iba na to, čo sa nazýva „hodnota L“. Hodnota L je výraz, ktorý sa týka miesta pamäte, ako je premenná, pole poľa alebo pole v rámci štruktúry. Prevádzkovateľ adresy nemôžete použiť na konštantu alebo dočasnú hodnotu vytvorenú výrazom (napr. `&(5 + 3)` je neplatný).

* Typ údajov: Operátor adresy vracia ukazovateľ, ktorého typ dát je dátový typ premennej, na ktorú sa používa. Napríklad, `&my_number` (kde` my_number` je `int`) vracia` int*`.

Stručne povedané, operátor adresy (`&`) je základným operátorom v C, ktorý poskytuje spôsob prístupu k umiestneniu pamäte premennej. Je nevyhnutné pre manipuláciu s ukazovateľom, funkčné hovory referenciou, dynamické pridelenie pamäte a práca so štruktúrami a odborovami. Pochopenie jeho účelu a funkčnosti je rozhodujúce pre písanie efektívnych a robustných programov C.