Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Lvalue referenca na polje: `(&items)[3]`

`int* (&items)[3]` referencira cijelo polje od tri pokazivača. Veličina ostaje dio tipa, a objekt za čišćenje može mijenjati elemente izvornog polja.

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

Sintaksa

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

U deklaraciji int* (&items)[3] zagrade grupiraju &items: & deklarira lvalue referencu, [3] određuje broj elemenata, a int* je tip svakog elementa. Referenca se izravno veže za postojeće promjenjivo polje tipa int*[3], bez kopiranja ili pretvorbe polja u pokazivač. Poslije se ne može vezati za drugo polje. Dodjela u items[0] mijenja prvi element izvornog polja.

int* items[3] deklarira polje pokazivača, no kod parametra funkcije tip se prilagođava u int** i ne zahtijeva tu veličinu. int* (*items)[3] pokazivač je na cijelo polje, a ne referenca. Bez zagrada bi int* &items[3] deklariralo nedopušteno polje referenci. Referentni parametar iz primjera ne prihvaća ni običan int** ni polje od četiri pokazivača.

AllocationGuard veže se za pointers, čiji su elementi u početku nul-pokazivači. U petlji int*& p referencira sam element, umjesto da kopira vrijednost pokazivača. Polje mora nadživjeti objekt za čišćenje: njegov destruktor koristi polje pri normalnom izlasku iz bloka i pri odmatanju stoga do rukovatelja iznimkom. Tako može osloboditi objekte uspješno alocirane prije pogreške.

delete pointers[0] ne postavlja element na nulu. Neposredna dodjela pointers[0] = nullptr osigurava da objekt za čišćenje vidi nul-pokazivač umjesto da pokuša ponovno izbrisati isti objekt, što bi moglo prouzročiti nedefinirano ponašanje. Primjena delete na nul-pokazivač valjana je. Ovdje se koristi delete jer svaki new int stvara jedan objekt; uz new[] ide delete[]. Svaki element koji nije nul-pokazivač mora pokazivati na različit objekt koji treba izbrisati. U produkcijskom kodu za isključivo vlasništvo radije koristite std::unique_ptr.

Primjeri

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

Rezultat

All slots are null: true

Očekivani se redak ispisuje nakon izvršavanja destruktora objekta za čišćenje. Prvi je element izričito postavljen na nulu; destruktor briše preostala dva objekta i postavlja njihove elemente na nulu u istom polju.

Povezane lekcije

  • C++ · Lekcija 20 · Napredno · Verzija: 3

Izvori