CKTIS / C++
Lvalue-Referenz auf ein Array: `(&items)[3]`
`int* (&items)[3]` referenziert das gesamte Array aus drei Zeigern. Die Elementanzahl bleibt Teil des Typs, und ein Wächter kann die ursprünglichen Zeiger ändern.
Version: ISO C++23; implementation support may vary
Syntax
T (&items)[3] = array;
T* (&items)[3] = pointerArray;In int* (&items)[3] gruppieren die Klammern &items: & deklariert eine Lvalue-Referenz, [3] gibt die Elementanzahl an und int* ist der Elementtyp. Die Referenz bindet direkt an ein vorhandenes veränderbares Array vom Typ int*[3], ohne Kopie oder Umwandlung in einen Zeiger. Sie kann später nicht neu gebunden werden. Eine Zuweisung an items[0] ändert den ersten Eintrag des Originals.
int* items[3] deklariert ein Zeigerarray; als Funktionsparameter wird der Typ jedoch zu int** angepasst und erzwingt die Elementanzahl nicht. int* (*items)[3] ist ein Zeiger auf das ganze Array, keine Referenz. Ohne Klammern würde int* &items[3] ein unzulässiges Array aus Referenzen deklarieren. Der Referenzparameter des Beispiels akzeptiert weder einen bloßen int** noch ein Array aus vier Zeigern.
AllocationGuard bindet an pointers, dessen Einträge anfangs Nullzeiger sind. In der Schleife referenziert int*& p jeweils den Zeigereintrag selbst, statt seinen Wert zu kopieren. Das Array muss den Wächter überleben: Sein Destruktor nutzt es beim normalen Verlassen des Blocks und beim Abwickeln des Stacks bis zu einem Ausnahmehandler. So kann er auch vor einem Fehler erfolgreiche Allokationen aufräumen.
delete pointers[0] setzt den Eintrag nicht zurück. Durch das sofortige pointers[0] = nullptr sieht der Wächter einen Nullzeiger und versucht nicht, dasselbe Objekt erneut zu löschen, was undefiniertes Verhalten zur Folge haben kann. delete mit einem Nullzeiger ist zulässig. Hier passt delete, weil jedes new int ein einzelnes Objekt erzeugt; zu new[] gehört delete[]. Jeder Nicht-Null-Eintrag muss auf ein anderes zu löschendes Objekt zeigen. In Produktionscode ist std::unique_ptr für exklusiven Besitz vorzuziehen.
Beispiele
#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';
}Ergebnis
All slots are null: true
Die erwartete Zeile erscheint nach dem Destruktoraufruf. Der erste Eintrag wurde ausdrücklich zurückgesetzt; der Wächter löscht die beiden übrigen Objekte und setzt deren Einträge im selben Array zurück.
Zugehörige Lektionen
- C++ · Lektion 20 · Fortgeschritten · Version: 3
Quellen
- 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]