Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Referência lvalue para um array: `(&items)[3]`

`int* (&items)[3]` referencia o array completo de três ponteiros. O tamanho faz parte do tipo e um objeto guardião pode atualizar os elementos do array original.

Versão: ISO C++23; implementation support may vary

Sintaxe

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

Em int* (&items)[3], os parênteses agrupam &items: & declara uma referência lvalue, [3] indica o número de elementos e int* é o tipo de cada elemento. A referência liga-se diretamente a um array modificável existente do tipo int*[3], sem cópia nem conversão do array em ponteiro. Não pode ser ligada posteriormente a outro array. Atribuir um valor a items[0] altera a primeira posição do original.

int* items[3] declara um array de ponteiros, mas, como parâmetro de função, o tipo é ajustado para int** e não impõe o tamanho. int* (*items)[3] é um ponteiro para o array inteiro, não uma referência. Sem parênteses, int* &items[3] declararia um array de referências, o que não é permitido. O parâmetro por referência do exemplo não aceita um simples int** nem um array de quatro ponteiros.

AllocationGuard liga-se a pointers, cujas posições contêm inicialmente ponteiros nulos. No ciclo, int*& p referencia cada posição em vez de copiar o valor do ponteiro. O array tem de sobreviver ao guardião: o destrutor usa-o na saída normal do bloco e durante o desenrolamento da pilha até um tratador de exceções. Assim, pode libertar os objetos que tenham sido alocados antes de uma falha.

delete pointers[0] não repõe o ponteiro a nulo. A atribuição imediata pointers[0] = nullptr faz com que o guardião encontre um ponteiro nulo em vez de tentar uma segunda eliminação, que poderia provocar comportamento indefinido. Aplicar delete a um ponteiro nulo é válido. Usa-se delete porque cada new int cria um único objeto; uma alocação com new[] exige delete[]. Cada posição não nula tem de apontar para um objeto distinto a eliminar. Em código de produção, prefira std::unique_ptr para representar a propriedade exclusiva.

Exemplos

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

Resultado

All slots are null: true

A linha esperada é escrita depois de o destrutor do guardião ser executado. A primeira posição foi explicitamente reposta a nulo; o guardião elimina os outros dois objetos e repõe a nulo as respetivas posições no mesmo array.

Lições relacionadas

  • C++ · Lição 20 · Avançado · Versão: 3

Fontes