Puntatori

#include <stdio.h>
#include <stdlib.h>

int main() {

 /*
   Una variabile corrisponde a una locazione di memoria capace di ospitare
   valori corrispondenti al tipo di variabile dichiarata.
   Una variabile intera, ad esempio, corrisponde ad una locazione di 4 byte
   che vengono interpretati in base alla codifica dei numeri interi.
   Oppure, una variabile double corrisponde ad una locazione di 8 byte
   interpretati in base alla codifica dei numeri floating-point.
  
   Un puntatore, da questo punto di vista, e' una variabile come le altre:
   corrisponde ad una locazione di memoria capace di ospitare dei valori.
   La differenza (essenziale) e' che il tipo di valori ospitati in una
   variabile di tipo puntatore e' proprio l'INDIRIZZO DI MEMORIA (di
   una qualche variabile).
   Cosi' una variabile di tipo puntatore-a-interi, potra' ospitare (come
   valore!) l'indirizzo di memoria corrispondente a una variabile intera.
   Un puntatore-a-double ospitera' indirizzi di memoria corrispondenti a
   variabili double.
   E' importante sottolineare che i puntatori sono sempre
   "puntatori-a-qualcosa": non esistono (in realta' esistono, ma hanno
   una sintassi propria, esplicita...) puntatori a locazioni di memoria
   "generici", senza specificazione del tipo di locazione di cui il
   puntatore gestisce gli indirizzi.

 */

  //dichiarazione di una variabile:
  float variabile_float;
 int variabile_intera;

 //dichiarazione di un puntatore:
  float *puntatore_a_float;
 int *puntatore_a_int;
 //antepongo un asterisco davanti al nome della variabile

  //una variabile float puo' contenere un valore numerico in virgola mobile:
  variabile_float=5.5;
 //e similmente:
  variabile_intera=10;

 //un puntatore a float, puo' contenere un indirizzo di una variabile float:
  puntatore_a_float = &variabile_float;
 //l'operatore & davanti al nome di una variabile (qualsiasi) ne restituisce
  //l'indirizzo di memoria

  //Similmente:
  puntatore_a_int = &amp;variabile_intera;

 //mentre, ovviamente, sarebbe sbagliata un'assegnazione del tipo:
  //puntatore_a_int = &variabile_float;
  //perche', come si diceva, un puntatore e' sempre legato a un certo "tipo" di
  //variabili cui puo' immagazzinare l'indirizzo

  /*
   Per avere un'idea piu' concreta, proviamo a stampare a video il contenuto
   di alcune variabili normali e di variabili di tipo puntatore:
 */

  printf("\n\n");
 printf("variabile_intera contiene il valore: %d\n", variabile_intera);
 printf("puntatore_a_int contiene il valore: %p\n", puntatore_a_int);
 //il codice %p e' usato come segnaposto per i puntatori nel comando printf
  //il formato di printf per un puntatore e' un numero in base 16 con
  //un prefisso di due caratter: 0x (zero, ics)
  printf("e in effetti l'indirizzo di variabile_intera e': %p\n", &variabile_intera);
 printf("l'indirizzo di puntatore_a_int, invece, e': %p\n",&puntatore_a_int);
 printf("che non ha nulla a che fare col suo contentuo...\n");

 //Se volessimo "giocare" con l'indirizzo di memoria di puntatore_a_int,
  //dovremmo usare una variabile capace di gestire questo tipo di indirizzi:
  int **puntatore_a_puntatore_a_int;
 //notare il doppio asterisco (puntatore-a-puntatore-a-...)
  //(e ovviamente la generalizzazione con un numero fissato ma arbitrario di
  //asterischi e' del tutto lecita in C++)

  puntatore_a_puntatore_a_int = &puntatore_a_int;
 printf("il contenuto di puntatore_a_puntatore_a_int, invece, e': %p\n",puntatore_a_puntatore_a_int);
 printf("ovvero, proprio l'indirizzo di puntatore_a_int!!\n");

 printf("\n\n");


 /*
    Oltre all'operatore &, ovvero l'operatore "indirizzo di", riferito
    a una variabile, esiste l'operatore contrario: "contenuto di", riferito a un
    indirizzo, ossia a un puntatore: datemi l'indirizzo di una variabile, e io vi
    restituiro' il contenuto di quella variabile di cui mi avete dato l'indirizzo.
    Il contetto e' molto semplice. La cosa molto confusionaria e' che questo
    operatore e' realizzato in C++ con lo stesso simbolo che si usa per DICHIARARE
    un variabile-puntatore: l'asterisco.
 */
  printf("Il contenuto della variabile all'indirizzo %p, e' %d\n\n",
 puntatore_a_int,
 *puntatore_a_int);
 /*
   Chiariamo, dunque:
  
   - in DICHIARAZIONE, l'asterisco anteposto a al nome di una variabile,
   indica che la variabile che stiamo dichiarando e' un puntatore;
  
   - in un'ESPRESSIONE, l'asterisco davanti al nome di una variabile-puntatore
   indica che stiamo considerando il contenuto della locazione di memoria
   all'indirizzo memorizzato dalla quella variabile-puntatore
   (non e' possibile anteporre un asterisco ad una variabile comune)
  
 */
 
 //Pertanto, espressioni come le seguenti sono del tutto legittime:

  int i = 10;     //dichiarazione (variabile normale)
  int j = 20;
 int *pi, *pj;   //dichiarazione (asterisco: e' un puntatore!)
 
 //espressione: l'asterisco rappresenta "il contenuto all'indirizzo:"
  pi = &i; //uso di "indirizzo di"
  j = *pi; //uso di "contenuto all'indirizzo in"
  //e' come se avessimo scritto: j = i; dal momento che pi contiene proprio
  //l'indirizzo di i, per l'assegnazione immediatamente precedente! 

  /*
   Una volta chiarito il senso degli operatori unari, il loro "risultato" (ovvero
   "l'indirizzo di questa variabile" o "il contenuto all'indirizzo di questo
   puntatore", si comportano del tutto normalmente, e possono essere usati anche
   in contesti complessi:
 */
 
 int z;

 z = *(&i) + *(&j); //modo complicato per scrivere z = i + j;
  z = (*pi + 5); //sommo 5 al contenuto (intero) all'indirizzo memorizzato in pi

  //attenzione a questa:
  *pi = 5;
 /*
   Assegno il valore 5 alla cella di memoria il cui indirizzo e' memorizzato in pi.
   Se quell'indirizzo era l'indirizzo di una variabile gia' dichiarata (nel nostro
   caso la variabile i, secondo l'assegnazione a riga 219), significa che stiamo
   effettivamente modificando il contenuto di quella variabile: e' come aver
   scritto i=5;
 */
 
 float x=355.0/113.0;
 float *px;
 px = &x; //[*]
  printf("x vale: %g \n",x);
 *px = 2 * x;  //e' come aver scritto: x = 2*x; dal moemnto che [*]
  printf("x ora vale: %g \n",x);

 printf("\n\n");



 return 0;
}