KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Lvalue-referentie naar een array: `(&items)[3]`

`int* (&items)[3]` verwijst naar de volledige array van drie pointers. De lengte blijft deel van het type en een bewaker kan de oorspronkelijke pointerelementen wijzigen.

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

Syntax

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

In int* (&items)[3] groeperen de haakjes &items: & declareert een lvalue-referentie, [3] geeft het aantal elementen aan en int* is het elementtype. De referentie bindt rechtstreeks aan een bestaande wijzigbare array van het type int*[3], zonder kopie of omzetting van de array naar een pointer. De referentie kan later niet aan een andere array worden gebonden. Een toewijzing aan items[0] wijzigt het eerste element van het origineel.

int* items[3] declareert een array van pointers, maar als functieparameter wordt het type aangepast tot int** en wordt de lengte niet afgedwongen. int* (*items)[3] is een pointer naar de hele array, geen referentie. Zonder haakjes zou int* &items[3] een array van referenties declareren, wat niet is toegestaan. De referentieparameter in het voorbeeld accepteert geen losse int** en geen array van vier pointers.

AllocationGuard bindt aan pointers, waarvan de elementen aanvankelijk nullpointers zijn. In de lus verwijst int*& p naar het pointerelement zelf, zonder de waarde te kopiëren. De array moet langer blijven bestaan dan de bewaker: de destructor gebruikt de array bij het normaal verlaten van het blok en bij het afwikkelen van de stack tot aan een exceptionhandler. Zo kunnen ook objecten worden opgeruimd die vóór een fout zijn aangemaakt.

delete pointers[0] zet het element niet op nul. Door direct pointers[0] = nullptr toe te wijzen, ziet de bewaker een nullpointer in plaats van hetzelfde object opnieuw te verwijderen, wat ongedefinieerd gedrag kan veroorzaken. delete op een nullpointer is toegestaan. Hier hoort delete bij elk afzonderlijk object dat new int aanmaakt; bij new[] hoort delete[]. Elk niet-nul element moet naar een ander te verwijderen object wijzen. Gebruik in productiecode bij voorkeur std::unique_ptr voor exclusief eigendom.

Voorbeelden

#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';
}

Resultaat

All slots are null: true

De verwachte regel wordt afgedrukt nadat de destructor van de bewaker is uitgevoerd. Het eerste element is expliciet op nul gezet; de bewaker verwijdert de andere twee objecten en zet hun elementen in dezelfde array op nul.

Gerelateerde lessen

  • C++ · Les 20 · Gevorderd · Versie: 3

Bronnen