CKTIS / C++
Gelöschte Funktion (`= delete`)
Sperre eine bestimmte Überladung oder verhindere das Kopieren bereits beim Kompilieren, ohne das Verschieben oder die korrekte Zerstörung der verborgenen Implementierung zu verhindern.
Version: ISO C++23; implementation support may vary
Syntax
void f(int) = delete;
// Inside class T:
T(const T&) = delete;
T& operator=(const T&) = delete;In C++23 definiert = delete; eine Funktion ausdrücklich als gelöscht. Der Zusatz muss in ihrer ersten Deklaration stehen. Die Funktion darf weder aufgerufen noch darf ihre Adresse genommen werden. Das gilt für Memberfunktionen und für Funktionen im Namensraumbereich. Anders als ein delete-Ausdruck wie delete p; zerstört = delete; kein Objekt und gibt keinen Speicher frei.
Eine mit = delete ausdrücklich gelöschte Überladung nimmt weiterhin an der Überladungsauflösung teil. Bei void f(double); und void f(int) = delete; wählt f(1) die exakte Übereinstimmung f(int) und ist unzulässig: Der Compiler weicht nicht auf f(double) aus. f(1.0) wählt f(double). Ein standardmäßig erzeugter Verschiebekonstruktor oder Verschiebezuweisungsoperator, der als gelöscht definiert wird, bleibt bei der Überladungsauflösung hingegen unberücksichtigt.
Widget löscht den Kopierkonstruktor und den Kopierzuweisungsoperator. Für den Verschiebekonstruktor, den Verschiebezuweisungsoperator und den Destruktor fordert = default die vom Compiler nach den Sprachregeln erzeugte Definition an. Eine so angeforderte Funktion kann dennoch als gelöscht definiert werden, wenn eine benötigte Operation für ein Datenelement oder eine Basisklasse nicht verfügbar ist.
Beim PImpl-Idiom lässt sich std::unique_ptr<Impl> deklarieren, solange Impl noch unvollständig ist. Der Standard-Deleter benötigt jedoch einen vollständigen Typ. Das ist bei der Zerstörung und bei der Verschiebezuweisung wichtig: Letztere kann das zuvor vom Ziel besessene Objekt zerstören. Deshalb definiert das Beispiel den Destruktor und beide Verschiebeoperationen außerhalb der Klasse, nach der Definition von Impl. Bei getrennten Dateien bleiben die Deklarationen im Header, die Definitionen kommen in die .cpp-Datei.
Beispiele
#include <iostream>
#include <memory>
#include <type_traits>
#include <utility>
class Widget {
public:
Widget();
~Widget();
Widget(const Widget&) = delete;
Widget& operator=(const Widget&) = delete;
Widget(Widget&&) noexcept;
Widget& operator=(Widget&&) noexcept;
bool has_impl() const noexcept { return static_cast<bool>(impl_); }
private:
struct Impl;
std::unique_ptr<Impl> impl_;
};
struct Widget::Impl {};
Widget::Widget() : impl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;
static_assert(!std::is_copy_constructible_v<Widget>);
static_assert(!std::is_copy_assignable_v<Widget>);
static_assert(std::is_move_constructible_v<Widget>);
static_assert(std::is_move_assignable_v<Widget>);
int main() {
Widget a;
// Widget copy(a);
Widget b(std::move(a));
Widget c;
// c = b;
c = std::move(b);
std::cout << std::boolalpha << a.has_impl() << ' '
<< b.has_impl() << ' ' << c.has_impl() << '\n';
}
Ergebnis
false false true
Die `static_assert`-Prüfungen zeigen, dass Kopieren gesperrt und Verschieben erlaubt ist. `false false true` bedeutet, dass nach beiden Verschiebeoperationen nur `c` ein `Impl` besitzt. Entferne die Kommentarzeichen jeweils bei nur einem Kopierversuch, um einen Kompilierfehler zu sehen.
Zugehörige Lektionen
- C++ · Lektion 11 · Fortgeschritten · Version: 3
Quellen
- Deleted definitions [dcl.fct.def.delete]
- Explicitly-defaulted functions [dcl.fct.def.default]
- Delete [expr.delete]
- Default deleter for single objects [unique.ptr.dltr.dflt]
- unique_ptr constructors [unique.ptr.single.ctor]
- unique_ptr destructor [unique.ptr.single.dtor]
- unique_ptr assignment [unique.ptr.single.asgn]
- C++23 working draft N4950