Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Referencia lvalue a un array: `(&items)[3]`

`int* (&items)[3]` se refiere al array completo de tres punteros. El tamaño sigue formando parte del tipo y un guardián puede modificar las posiciones del array original.

Versión: ISO C++23; implementation support may vary

Sintaxis

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

En int* (&items)[3], los paréntesis agrupan &items: & declara una referencia lvalue, [3] fija el número de elementos e int* es el tipo de cada elemento. La referencia se vincula directamente a un array modificable existente de tipo int*[3], sin copiarlo ni convertirlo en un puntero. No puede volver a vincularse a otro array. Asignar a items[0] modifica la primera posición del original.

int* items[3] declara un array de punteros, pero como parámetro de función su tipo se ajusta a int** y no exige ese tamaño. int* (*items)[3] es un puntero al array completo, no una referencia. Sin paréntesis, int* &items[3] declararía un array de referencias, que no es válido. El parámetro por referencia del ejemplo no acepta un int** sin más ni un array de cuatro punteros.

AllocationGuard se vincula a pointers, cuyas posiciones contienen inicialmente punteros nulos. En el bucle, int*& p referencia cada posición en lugar de copiar el valor del puntero. El array debe vivir más que el guardián: su destructor lo usa al salir normalmente del bloque y al desenrollar la pila hasta un manejador de excepciones. Así puede liberar los objetos que se hayan asignado antes de un fallo.

delete pointers[0] no pone la posición a cero. Asignar inmediatamente pointers[0] = nullptr hace que el guardián vea un puntero nulo en lugar de intentar eliminar el mismo objeto dos veces, lo que podría provocar un comportamiento indefinido. Aplicar delete a un puntero nulo es válido. Aquí se usa delete porque cada new int crea un solo objeto; para una asignación con new[] se usa delete[]. Cada posición no nula debe apuntar a un objeto distinto que deba eliminarse. En producción, es preferible usar std::unique_ptr para representar la propiedad exclusiva.

Ejemplos

#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

La línea esperada se imprime después de que se ejecute el destructor del guardián. La primera posición se puso a nulo explícitamente; el guardián elimina los otros dos objetos y pone a nulo sus posiciones en el mismo array.

Lecciones relacionadas

  • C++ · Lección 20 · Avanzado · Versión: 3

Fuentes