WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Gelöschte Funktionen (`= delete`) in C++

Mit `= delete` verbietest du die Verwendung einer bestimmten Funktion zur Übersetzungszeit. So lässt sich eine unerwünschte Überladung sperren oder das Kopieren und Verschieben eines Pools verhindern.

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

Syntax

void f(int);
void f(double) = delete;

struct Pool {
    explicit Pool(int value);
    Pool(double) = delete;
    Pool(const Pool&) = delete;
    Pool& operator=(const Pool&) = delete;
    Pool(Pool&&) = delete;
    Pool& operator=(Pool&&) = delete;
};

Die seit C++11 verfügbare und in ISO C++23 enthaltene Schreibweise = delete; definiert eine Funktion bereits bei ihrer ersten Deklaration ausdrücklich als gelöscht, ohne Funktionsrumpf in geschweiften Klammern. Das gilt für Memberfunktionen und für Funktionen im Namensraumbereich. Ein Aufruf, auch ein impliziter, oder das Bilden ihrer Adresse führt zu einem Übersetzungsfehler, nicht zu einem Laufzeitfehler.

Eine ausdrücklich gelöschte Überladung nimmt weiterhin an der Überladungsauflösung teil. Wird sie ausgewählt, ist der Aufruf unzulässig; der Compiler weicht nicht auf eine schlechter passende Überladung aus. Bei Pool{42.0} passt Pool(double) genau. Eine Konvertierung nach int rettet den Aufruf daher nicht. Anders ist es bei einem mit default versehenen Verschiebekonstruktor oder Verschiebezuweisungsoperator, der als gelöscht definiert wird: Er wird bei der Überladungsauflösung ignoriert.

Pool besitzt einen einzelnen Speicherplatz und hält einen Zeiger auf das Objekt im eigenen Puffer. Würde nur der Zeigerwert kopiert, zeigte er weiterhin in den Puffer des Quellobjekts. Deshalb löscht die Klasse den Kopierkonstruktor und den Kopierzuweisungsoperator ebenso ausdrücklich wie den Verschiebekonstruktor und den Verschiebezuweisungsoperator.

Die nicht allokierende Standardform ::new (Adresse) T{...} konstruiert ein Objekt in vorhandenem, ausreichend großem und passend ausgerichtetem Speicher. Der explizite Destruktoraufruf item_->~Item() beendet die Lebensdauer des Objekts, ohne den Puffer freizugeben. Die Ausdrücke delete p und delete[] p dienen der Zerstörung von Objekten und der Freigabe von Speicher aus der jeweils passenden allokierenden new-Form. Verwende sie nicht für das Objekt in diesem Puffer. = delete selbst zerstört keine Objekte und gibt keinen Speicher frei.

Beispiele

#include <cstddef>
#include <iostream>
#include <new>
#include <type_traits>

class Pool {
    struct Item { int value; };
    alignas(Item) std::byte slot_[sizeof(Item)];
    Item* item_;

public:
    explicit Pool(int value)
        : item_(::new (static_cast<void*>(slot_)) Item{value}) {}
    Pool(double) = delete;
    Pool(const Pool&) = delete;
    Pool& operator=(const Pool&) = delete;
    Pool(Pool&&) = delete;
    Pool& operator=(Pool&&) = delete;

    ~Pool() { item_->~Item(); }
    int value() const noexcept { return item_->value; }
};

static_assert(!std::is_copy_constructible_v<Pool>);
static_assert(!std::is_copy_assignable_v<Pool>);
static_assert(!std::is_move_constructible_v<Pool>);
static_assert(!std::is_move_assignable_v<Pool>);

int main() {
    Pool a{42};
    std::cout << a.value() << '\n';

    // Pool b = a;
    // Pool c{42.0};
}

Ergebnis

42

Die vier `static_assert`-Prüfungen decken Konstruktion und Zuweisung durch Kopieren und Verschieben ab. Das Programm sollte `42` ausgeben. Hebe die Auskommentierung der letzten beiden Deklarationen jeweils einzeln auf: Die Übersetzung sollte scheitern, weil ein gelöschter Konstruktor ausgewählt wird.

Zugehörige Lektionen

  • C++ · Lektion 19 · Fortgeschritten · Version: 3

Quellen