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
- C++ working draft — References [dcl.ref]
- C++ working draft — Arrays [dcl.array]
- C++ working draft — Reference initialization [dcl.init.ref]
- C++ working draft — Functions [dcl.fct]
- C++ working draft — The range-based for statement [stmt.ranged]
- C++ working draft — Declaration statement [stmt.dcl]
- C++ working draft — Stack unwinding [except.ctor]
- C++ working draft — Delete [expr.delete]
- C++ working draft — Unique-ownership pointers [unique.ptr]