Puntatori

Indirizzi di memoria delle variabili

Ogni variabile memorizzata nella memoria di un computer occupa una specifica posizione chiamata indirizzo di memoria. Questo indirizzo è rappresentato come un numero intero che identifica univocamente la locazione nella RAM in cui è memorizzata la variabile.

Cosa significa indirizzo di memoria

• Quando dichiariamo una variabile in C++, ad esempio:

  int numero = 42;

  il compilatore riserva una zona di memoria per la variabile numero. Questa zona è identificata da un indirizzo univoco, che possiamo ottenere utilizzando l’operatore di indirizzo &:

  cout << "Indirizzo di numero: " << &numero << endl;

  Il risultato sarà un valore esadecimale che rappresenta l’indirizzo.

Indirizzo e dimensione delle variabili

La dimensione di memoria occupata da una variabile dipende dal suo tipo di dato. Ad esempio:

• Un int occupa generalmente 4 byte.
• Un char occupa 1 byte.
• Un double occupa 8 byte.

L’indirizzo rappresenta il primo byte della memoria occupata dalla variabile.

Cosa sono i puntatori

Un puntatore è una variabile speciale che contiene l’indirizzo di memoria di un’altra variabile. In altre parole, mentre le normali variabili memorizzano valori, i puntatori memorizzano indirizzi (che sono anche loro a tutti gli effetti dei valori).

Tipo e indirizzo dei puntatori

Anche un puntatore è una variabile, quindi:

• Un puntatore ha un indirizzo proprio, che può essere ottenuto con &.
• Un puntatore ha un tipo di dato, che dipende dal tipo della variabile a cui punta:

  int numero = 42;
  int *ptr = № // 'ptr' è un puntatore a int

Nel codice sopra:

• ptr memorizza l’indirizzo di numero.
• Il tipo int * specifica che ptr punta a una variabile di tipo int.

Dimensione dei puntatori

La dimensione di un puntatore dipende dall’architettura del sistema:

• Su sistemi a 32 bit, un puntatore occupa 4 byte.
• Su sistemi a 64 bit, un puntatore occupa 8 byte. Indipendentemente dal tipo di variabile a cui punta, la dimensione del puntatore è sempre la stessa, perché rappresenta un indirizzo nella memoria e non il valore contnuto a quell’indirizzo.

Operazioni principali sui puntatori

Dichiarazione dei puntatori

Essendo una variabile, la dichiarazione di un puntatore segue le regole generali delle altre variabili, con l’aggiunta del simbolo * accanto al tipo:

int *ptr; // Dichiarazione di un puntatore a int

Il tipo della variabile include il simbolo * perché il puntatore “punta” a una variabile di un certo tipo. Ad esempio:

• int * indica un puntatore a un intero (int).
• double * indica un puntatore a un numero in virgola mobile (double). È importante ricordare che un puntatore, essendo una variabile, ha un suo indirizzo di memoria e una sua dimensione, che dipende dall’architettura del sistema (es. 4 byte su sistemi a 32 bit, 8 byte su sistemi a 64 bit).

Assegnamento

Quando assegniamo un valore a un puntatore, gli stiamo dicendo quale indirizzo deve contenere, ovvero dove “puntare”. Per farlo, utilizziamo l’operatore di indirizzo &, che restituisce l’indirizzo di una variabile.

int numero = 42;     // Dichiarazione di una variabile
int *ptr = №  // Assegniamo a 'ptr' l'indirizzo di 'numero'

Qui, il puntatore ptr ora contiene l’indirizzo di memoria di numero. Questo significa che ptr sa dove trovare numero nella RAM. Possiamo verificare l’indirizzo:

cout << "Indirizzo di numero: " << &numero << endl;
cout << "Valore di ptr: " << ptr << endl; // Stampa lo stesso indirizzo

Dereferenziazione

La dereferenziazione è l’operazione che consente di accedere al valore memorizzato all’indirizzo contenuto nel puntatore. Per farlo, si utilizza l’operatore * davanti al puntatore.

int numero = 42;
int *ptr = №

cout << "Valore puntato da ptr: " << *ptr << endl; // Stampa 42

In questo esempio:

• ptr contiene l’indirizzo di numero.
• Usando *ptr, seguiamo l’indirizzo per accedere al valore di numero.

La dereferenziazione consente non solo di leggere, ma anche di modificare il valore della variabile puntata:

*ptr = 10; // Modifica il valore di 'numero' tramite il puntatore
cout << "Nuovo valore di numero: " << numero << endl; // Stampa 10

Esempio completo

Esempio di Assegnamento e Dereferenziazione

#include <iostream>
using namespace std;

int main() {
    int numero = 5;         // Variabile normale
    int *ptr = &numero;     // Puntatore a 'numero'

    cout << "Indirizzo di numero: " << &numero << endl;
    cout << "Valore di numero: " << numero << endl;

    // Usare il puntatore per accedere al valore di 'numero'
    cout << "Valore puntato da ptr: " << *ptr << endl;

    // Modificare 'numero' tramite il puntatore
    *ptr = 20; // Cambia il valore di 'numero'
    cout << "Nuovo valore di numero: " << numero << endl;

    return 0;
}

Risultato atteso:

Indirizzo di numero: 0x7ffee4a2c4a8 (esempio, varia tra esecuzioni)
Valore di numero: 5
Valore puntato da ptr: 5
Nuovo valore di numero: 20

Errori comuni nell’uso dei puntatori

1. Puntatori non inizializzati: Se un puntatore non è inizializzato (contiene “schifo”), punta a un indirizzo casuale:

   int *ptr; // Non inizializzato
   *ptr = 10; // Errore: accesso a memoria non valida

2. Dereferenziare puntatori nulli: Un puntatore nullo (nullptr) non può essere dereferenziato:

   int *ptr = nullptr;
   cout << *ptr; // Errore: crash dell'applicazione

Best practice:

• Inizializzare i puntatori a nullptr se non si sa subito cosa devono puntare.
• Controllare sempre se un puntatore è nullo prima di dereferenziarlo:

  if (ptr != nullptr) {
      cout << *ptr << endl;
  }

#include <iostream>
using namespace std;

struct Persona {
    string nome;
    string cognome;
    string data_nascita;
};

int main() {
    Persona persona = {"Mario", "Rossi", "01/01/1980"};

    cout << "Nome: " << persona.nome << endl;
    cout << "Cognome: " << persona.cognome << endl;
    cout << "Data di nascita: " << persona.data_nascita << endl;

    return 0;
}

struct Persona {
    string nome;
    string cognome;
    string data_nascita;
    Persona padre;  // Errore! Definizione ricorsiva della struct Persona
    Persona madre;  // Errore! Definizione ricorsiva
};

struct Persona {
    string nome;
    string cognome;
    string data_nascita;
    Persona *padre;  // Puntatore alla struct del padre
    Persona *madre;  // Puntatore alla struct della madre
};

#include <iostream>
using namespace std;

struct Persona {
    string nome;
    string cognome;
    string data_nascita;
    Persona *padre;  // Puntatore al padre
    Persona *madre;  // Puntatore alla madre
};

int main() {
    // Creazione dei genitori
    Persona padre = {"Luigi", "Rossi", "15/03/1955", nullptr, nullptr};
    Persona madre = {"Anna", "Bianchi", "20/07/1960", nullptr, nullptr};

    // Creazione del figlio
    Persona figlio = {"Mario", "Rossi", "01/01/1980", &padre, &madre};

    // Stampa dei dati del figlio
    cout << "Figlio: " << figlio.nome << " " << figlio.cognome << endl;
    cout << "Nato il: " << figlio.data_nascita << endl;

    // Accesso ai genitori tramite i puntatori
    if (figlio.padre) {
        cout << "Padre: " << figlio.padre->nome << " " << figlio.padre->cognome << endl;
    }
    if (figlio.madre) {
        cout << "Madre: " << figlio.madre->nome << " " << figlio.madre->cognome << endl;
    }

    return 0;
}

*(figlio.padre).nome // Mi posiziono dal padre (utilizzando il puntatore) e accedo all'attributo nome

figlio.padre->nome // Mi posiziono dal padre e accedo all'attributo nome tutto in una operazione