In C, l'operatore dell'indirizzo (`&`) è un operatore unario che fornisce l'indirizzo di memoria di una variabile o oggetto. È uno strumento fondamentale per lavorare con puntatori, allocazione della memoria dinamica e chiamate di funzione per riferimento.
Scopo:
Lo scopo principale dell'operatore dell'indirizzo è di:
* Ottieni la posizione della memoria: Ti consente di recuperare l'indirizzo fisico in memoria in cui viene memorizzata una variabile. Questo è cruciale per la manipolazione del puntatore e la comprensione di come vengono memorizzate le variabili.
Funzionalità:
L'operatore `&`, quando applicato a una variabile, restituisce l'indirizzo di quella variabile . Questo indirizzo è una posizione di memoria rappresentata da un numero esadecimale (ad esempio, `0x7ffc94b2d8a0`).
Esempio:
`` `c
#include
int main () {
int my_number =10;
int *ptr; // dichiara un puntatore a un numero intero
ptr =&my_number; // Assegna l'indirizzo di My_number al puntatore PTR
printf ("valore di my_number:%d \ n", my_number);
printf ("indirizzo di my_number:%p \ n", &my_number); // %p è lo specificatore del formato per gli indirizzi di stampa
printf ("Valore di PTR:%p \ n", ptr);
printf ("valore indicato da ptr:%d \ n", *ptr); // Dereferencing the Pointer
restituzione 0;
}
`` `
output (varierà a seconda del sistema):
`` `
Valore di my_number:10
Indirizzo di my_number:0x7ffc94b2d8a0
Valore di PTR:0x7ffc94b2d8a0
Valore puntato da PTR:10
`` `
Spiegazione:
1. `int my_number =10;` :Dichiara una variabile intera `my_number` e la inizializza su 10. Il compilatore alloca una posizione di memoria per archiviare questa variabile.
2. `int *ptr;` :Dichiara una variabile puntatore `ptr` progettata per contenere l'indirizzo di una variabile intera.
3. `ptr =&my_number;` :Qui entra in gioco l'operatore dell'indirizzo. `&my_number` valuta l'indirizzo di memoria in cui è memorizzato` my_number`. Questo indirizzo viene quindi assegnato alla variabile puntatore `ptr`. Ora, `ptr` * punta a *` my_number`.
4. `printf (" Indirizzo di my_number:%p \ n ", &my_number);` :Stampa l'indirizzo di memoria di `my_number` utilizzando il formato`%p`.
5. `printf (" Valore di ptr:%p \ n ", ptr);` :Stampa il valore memorizzato in `ptr`, che è l'indirizzo di` my_number`. Si noti che l'indirizzo stampato qui è lo stesso dell'indirizzo di `my_number`.
6. `printf (" Valore puntato da ptr:%d \ n ", *ptr);` :Questa linea dimostra * dereferencing * il puntatore. L'operatore `*`, se utilizzato con un puntatore, accede al valore memorizzato nella posizione della memoria indicata dal puntatore. Quindi `*ptr` accede al valore di` my_number` (che è 10).
Usi comuni dell'operatore dell'indirizzo:
1. Puntatori: Come mostrato sopra, l'operatore dell'indirizzo è fondamentale per lavorare con i puntatori. I puntatori archiviano gli indirizzi di memoria e l'operatore dell'indirizzo fornisce tali indirizzi.
2. Chiamati di funzione per riferimento: C supporta le chiamate di funzione per valore e per riferimento. Per passare una variabile per riferimento, si passa il suo indirizzo alla funzione. La funzione può quindi modificare la variabile originale usando il puntatore che riceve.
`` `c
#include
void increment (int *numero) {
(*numero) ++; // Incrementa il valore all'indirizzo indicato dal "numero"
}
int main () {
int x =5;
printf ("prima dell'incremento:%d \ n", x);
incremento (&x); // Passa l'indirizzo di X alla funzione di incremento
printf ("Dopo incremento:%d \ n", x);
restituzione 0;
}
`` `
In questo esempio, `increment` modifica l'originale` x` perché riceve un puntatore a `x` (cioè il suo indirizzo).
3. Allocazione di memoria dinamica: Quando si alloca la memoria utilizzando dinamicamente funzioni come `malloc ()`, lavori con i puntatori alla memoria allocata. L'operatore dell'indirizzo viene spesso utilizzato implicitamente quando si passa un puntatore alla memoria allocata dinamicamente alle funzioni.
`` `c
#include
#include
int main () {
int *arr;
int size =5;
// Assegna la memoria per un array di 5 numeri interi
arc =(int *) malloc (dimensione * sizeof (int));
if (arr ==null) {
printf ("allocazione della memoria non riuscita! \ n");
Ritorno 1;
}
// Accesso elementi dell'array usando il puntatore aritmetico
per (int i =0; i
}
// Stampa gli elementi dell'array
per (int i =0; i
}
libero (arr); // libera la memoria allocata dinamicamente
restituzione 0;
}
`` `
`Malloc` restituisce un puntatore vuoto che deve quindi essere lanciato sul tipo di dati appropriato,` (int*) `In questo caso. La variabile `arr` contiene ora l'indirizzo iniziale del blocco di memoria allocato.
4. Strutture e sindacati: È possibile utilizzare l'operatore dell'indirizzo per ottenere l'indirizzo di una struttura o della variabile sindacale. Ciò è essenziale per passare le strutture alle funzioni in riferimento o per la creazione di puntatori alle strutture.
`` `c
#include
struct point {
int x;
int y;
};
int main () {
struct point p ={10, 20};
struct point *ptr_p =&p; // Ottieni l'indirizzo della struttura dei punti
printf ("Indirizzo di p:%p \ n", &p);
printf ("Indirizzo di p.x:%p \ n", &p.x); // Indirizzo del membro X
printf ("Indirizzo di P.Y:%p \ n", &p.y); // Indirizzo del membro Y
ptr_p-> x =5; // Accedi al membro X usando il puntatore
ptr_p-> y =15; // Accedi al membro Y usando il puntatore
printf ("p.x:%d, p.y:%d \ n", p.x, p.y); // output:p.x:5, p.y:15
restituzione 0;
}
`` `
Considerazioni importanti:
* valori L: L'operatore dell'indirizzo può essere applicato solo a quello che viene chiamato "valore L". Un valore L è un'espressione che si riferisce a una posizione di memoria, come una variabile, elemento array o un campo all'interno di una struttura. Non è possibile applicare l'operatore dell'indirizzo a una costante o un valore temporaneo prodotto da un'espressione (ad esempio, `&(5 + 3)` non è valido).
* Tipo di dati: L'operatore dell'indirizzo restituisce un puntatore il cui tipo di dati è il tipo di dati della variabile a cui viene applicato. Ad esempio, `&my_number` (dove` my_number` è un `int`) restituisce un` int*`.
In sintesi, l'operatore di indirizzo (`&`) è un operatore fondamentale in C che fornisce un modo per accedere alla posizione della memoria di una variabile. È essenziale per la manipolazione del puntatore, le chiamate di funzione per riferimento, l'allocazione della memoria dinamica e il lavoro con strutture e sindacati. Comprendere il suo scopo e la sua funzionalità è fondamentale per scrivere programmi C efficienti e robusti.
Informazioni correlate
Programmazione © www.354353.com