Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

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