KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Verwijderde functies (`= delete`) in C++

Met `= delete` maak je een specifieke functie onbruikbaar tijdens compilatie. Zo kun je een ongewenste overload weigeren of voorkomen dat een pool die geheugen beheert wordt gekopieerd of verplaatst.

Versie: 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;
};

De syntaxis = delete;, beschikbaar sinds C++11 en onderdeel van ISO C++23, definieert een functie bij haar eerste declaratie expliciet als verwijderd, zonder functielichaam tussen accolades. Dit werkt voor lidfuncties en voor functies op naamruimteniveau. Een verwijderde functie aanroepen, ook impliciet, of het adres ervan nemen is een compilatiefout, geen fout tijdens de uitvoering.

Een expliciet verwijderde overload doet nog mee aan de overloadresolutie. Wordt die gekozen, dan is de aanroep ongeldig: de compiler valt niet terug op een minder goed passende overload. Bij Pool{42.0} past Pool(double) exact, dus een conversie naar int redt de aanroep niet. Een moveconstructor of movetoewijzingsoperator die als default is gedeclareerd en vervolgens als verwijderd wordt gedefinieerd, wordt juist genegeerd bij de overloadresolutie.

Pool bezit één geheugenplek en bewaart een pointer naar het object in zijn eigen buffer. Als alleen de pointerwaarde wordt gekopieerd, blijft die naar de buffer van de bronpool wijzen. Daarom verwijdert de klasse expliciet zowel de kopieerconstructor en kopieertoewijzingsoperator als de moveconstructor en movetoewijzingsoperator.

De standaardvorm ::new (adres) T{...} alloceert geen geheugen, maar construeert een object in bestaand geheugen dat groot genoeg en juist uitgelijnd is. De expliciete destructoraanroep item_->~Item() beëindigt de levensduur van het object zonder de buffer vrij te geven. De expressies delete p en delete[] p dienen om objecten te vernietigen en geheugen vrij te geven dat met de bijbehorende allocerende vorm van new is verkregen. Gebruik ze niet voor het object in deze buffer. = delete zelf vernietigt geen objecten en geeft geen geheugen vrij.

Voorbeelden

#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};
}

Resultaat

42

De vier `static_assert`-controles toetsen constructie en toewijzing door kopiëren en verplaatsen. Het programma hoort `42` af te drukken. Haal bij elk van de laatste twee declaraties afzonderlijk de commentaartekens weg: compilatie hoort te mislukken omdat een verwijderde constructor wordt gekozen.

Gerelateerde lessen

  • C++ · Les 19 · Gevorderd · Versie: 3

Bronnen