CKTIS / C++
Verwijderde functie (`= delete`)
Blokkeer een specifieke overload of voorkom kopiëren tijdens het compileren, terwijl verplaatsen en het correct vernietigen van de verborgen implementatie mogelijk blijven.
Versie: 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 definieer je een functie expliciet als verwijderd door = delete; bij de eerste declaratie te zetten. Je kunt de functie niet aanroepen of het adres ervan nemen. Dit geldt voor lidfuncties en voor functies op naamruimteniveau. Het is geen delete-expressie zoals delete p;, die dient om een object te vernietigen en het geheugen vrij te geven, niet om een functie te blokkeren.
Een overload die expliciet met = delete is verwijderd, doet nog steeds mee aan de overloadresolutie. Bij void f(double); en void f(int) = delete; kiest f(1) de exacte overeenkomst f(int) en is de aanroep ongeldig: de compiler valt niet terug op f(double). De aanroep f(1.0) kiest f(double). Een verplaatsingsconstructor of verplaatsingstoewijzingsoperator waarvoor de standaarddefinitie geldt, wordt daarentegen bij overloadresolutie genegeerd als die als verwijderd wordt gedefinieerd.
Widget verwijdert de kopieerconstructor en de kopieertoewijzingsoperator. Voor de verplaatsingsconstructor, de verplaatsingstoewijzingsoperator en de destructor vraagt = default de compiler om ze volgens de taalregels te genereren. Zo’n functie kan toch als verwijderd worden gedefinieerd als een vereiste bewerking op een lid of basisklasse niet beschikbaar is.
Bij het PImpl-idioom mag je std::unique_ptr<Impl> declareren terwijl Impl nog onvolledig is, maar de standaarddeleter heeft een volledig type nodig. Dat is van belang bij vernietiging en bij verplaatsingstoewijzing, die het object dat het doel eerder bezat, kan vernietigen. Het voorbeeld definieert de destructor en beide verplaatsingsbewerkingen buiten de klasse, na de definitie van Impl. Splits je de code, dan blijven de declaraties in het headerbestand en komen deze definities in het .cpp-bestand.
Voorbeelden
#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';
}
Resultaat
false false true
De `static_assert`-controles tonen dat kopiëren is geblokkeerd en verplaatsen is toegestaan. `false false true` betekent dat alleen `c` na beide verplaatsingen een `Impl` bezit. Haal de twee kopieerpogingen één voor één uit commentaar om een compileerfout te zien.
Gerelateerde lessen
- C++ · Les 11 · Gevorderd · Versie: 3
Bronnen
- 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