CKTIS / C++
Référence lvalue à un tableau : `(&items)[3]`
`int* (&items)[3]` référence le tableau complet de trois pointeurs. La taille reste inscrite dans le type, et un garde peut modifier les pointeurs du tableau d’origine.
Version : ISO C++23; implementation support may vary
Syntaxe
T (&items)[3] = array;
T* (&items)[3] = pointerArray;Dans int* (&items)[3], les parenthèses regroupent &items : & déclare une référence lvalue, [3] fixe le nombre d’éléments et int* est le type de chaque élément. La référence se lie directement à un tableau modifiable existant de type int*[3], sans copie ni conversion du tableau en pointeur. Elle ne peut pas être liée ensuite à un autre tableau. Affecter items[0] modifie la première case du tableau d’origine.
int* items[3] déclare un tableau de pointeurs, mais dans une liste de paramètres de fonction, son type est ajusté en int** et n’impose pas la taille. int* (*items)[3] est un pointeur vers le tableau entier, pas une référence. Sans parenthèses, int* &items[3] déclarerait un tableau de références, ce qui est interdit. Le paramètre référence de l’exemple n’accepte ni un simple int** ni un tableau de quatre pointeurs.
AllocationGuard se lie à pointers, dont les cases contiennent initialement des pointeurs nuls. Dans la boucle, int*& p référence chaque case sans copier la valeur du pointeur. Le tableau doit survivre au garde : son destructeur y accède à la sortie normale du bloc et pendant le déroulement de la pile jusqu’à un gestionnaire d’exception. Il peut donc libérer les objets alloués avant un échec.
delete pointers[0] ne réinitialise pas la case. L’affectation immédiate pointers[0] = nullptr permet au garde de voir un pointeur nul au lieu de tenter une seconde suppression, qui risquerait de provoquer un comportement indéfini. Appliquer delete à un pointeur nul est valide. On utilise ici delete car chaque new int crée un seul objet ; une allocation par new[] exige delete[]. Chaque case non nulle doit désigner un objet distinct à supprimer. En production, privilégiez std::unique_ptr pour représenter la propriété exclusive.
Exemples
#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';
}Résultat
All slots are null: true
La ligne attendue s’affiche après l’exécution du destructeur du garde. La première case a été réinitialisée explicitement ; le garde supprime les deux autres objets et remet leurs cases à zéro dans le même tableau.
Leçons associées
- C++ · Leçon 20 · Avancé · Version : 3
Sources
- 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]