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
- 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]