Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Riferimento lvalue a un array: `(&items)[3]`

`int* (&items)[3]` riferisce l’intero array di tre puntatori. La dimensione fa parte del tipo e un oggetto di guardia può modificare gli elementi dell’array originale.

Versione: ISO C++23; implementation support may vary

Sintassi

T (&items)[3] = array;
T* (&items)[3] = pointerArray;

In int* (&items)[3], le parentesi raggruppano &items: & dichiara un riferimento lvalue, [3] specifica il numero di elementi e int* è il tipo di ogni elemento. Il riferimento si lega direttamente a un array modificabile esistente di tipo int*[3], senza copiarlo né convertirlo in un puntatore. Non può essere associato in seguito a un altro array. Assegnare a items[0] modifica il primo elemento dell’originale.

int* items[3] dichiara un array di puntatori, ma come parametro di funzione il tipo viene adattato a int** e non impone la dimensione. int* (*items)[3] è un puntatore all’intero array, non un riferimento. Senza parentesi, int* &items[3] dichiarerebbe un array di riferimenti, che non è ammesso. Il parametro per riferimento dell’esempio non accetta né un semplice int** né un array di quattro puntatori.

AllocationGuard si lega a pointers, i cui elementi sono inizialmente puntatori nulli. Nel ciclo, int*& p si riferisce alla singola posizione dell’array, senza copiare il valore del puntatore. L’array deve sopravvivere all’oggetto di guardia: il distruttore lo usa all’uscita normale dal blocco e durante lo svolgimento dello stack fino a un gestore di eccezioni. Può quindi liberare gli oggetti allocati prima di un errore.

delete pointers[0] non azzera l’elemento. L’assegnazione immediata pointers[0] = nullptr fa sì che la guardia veda un puntatore nullo, invece di tentare una seconda eliminazione che potrebbe provocare un comportamento indefinito. Applicare delete a un puntatore nullo è valido. Qui si usa delete perché ogni new int crea un solo oggetto; per un’allocazione con new[] si usa delete[]. Ogni elemento non nullo deve puntare a un oggetto distinto da eliminare. Nel codice di produzione è preferibile usare std::unique_ptr per rappresentare la proprietà esclusiva.

Esempi

#include <iostream>
#include <new>

class AllocationGuard {
    int* (&items)[3];

public:
    explicit AllocationGuard(int* (&array)[3]) noexcept : items(array) {}
    AllocationGuard(const AllocationGuard&) = delete;
    AllocationGuard& operator=(const AllocationGuard&) = delete;

    ~AllocationGuard() noexcept {
        for (int*& p : items) {
            delete p;
            p = nullptr;
        }
    }
};

int main() {
    int* pointers[3]{};
    try {
        AllocationGuard guard{pointers};
        pointers[0] = new int{10};
        pointers[1] = new int{20};
        pointers[2] = new int{30};

        delete pointers[0];
        pointers[0] = nullptr;
    } catch (const std::bad_alloc&) {
        return 1;
    }

    const bool allNull = pointers[0] == nullptr &&
                         pointers[1] == nullptr &&
                         pointers[2] == nullptr;
    std::cout << std::boolalpha << "All slots are null: " << allNull << '\n';
}

Risultato

All slots are null: true

La riga attesa viene stampata dopo l’esecuzione del distruttore della guardia. Il primo elemento è stato azzerato esplicitamente; la guardia elimina gli altri due oggetti e azzera i relativi elementi nello stesso array.

Lezioni correlate

  • C++ · Lezione 20 · Avanzato · Versione: 3

Fonti