KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

mutable — wijzigbare members en lambdafuncties

Het sleutelwoord mutable maakt het mogelijk een geselecteerd datalid te wijzigen, zelfs in een const-object. In een lambda heeft het een andere functie: de aanroepoperator operator() is dan niet standaard const, zodat wijzigbare kopieën van vastgelegde waarden kunnen worden aangepast.

Versie: C++23; repository compiler flag, production runtime not attested

Syntax

mutable T member;
[captures](parameters) mutable { body }

mutable heeft twee toepassingen. Bij een niet-statisch datalid van een klasse maakt het wijzigen van dat lid mogelijk, ook via een const-object en binnen een const-memberfunctie. Het versoepelt de beperkingen voor andere leden niet. Het lid zelf mag geen referentietype hebben en ook niet op het hoogste niveau met const zijn gekwalificeerd: mutable const int* p; is geldig, maar mutable int* const p; niet.

In een lambda zonder expliciete objectparameter zorgt [seed]() mutable { return ++seed; } ervoor dat operator() niet const is. Daardoor kan de vastgelegde kopie van seed worden aangepast; de toestand blijft behouden tussen aanroepen van hetzelfde lambda-object, terwijl het origineel ongewijzigd blijft. Zo’n lambda kan niet via een const-object worden aangeroepen. mutable verwijdert const niet uit het type van een vastgelegde waarde. Bij vastleggen via een referentie is mutable niet nodig om een wijzigbaar origineel aan te passen. mutable combineren met static of met een expliciete objectparameter is verboden.

In het voorbeeld is counter een const-object, maar next() verhoogt calls. De lambda verhoogt afzonderlijk haar eigen kopie van seed. De uitvoer is 1 2, gevolgd door 11 12 10. mutable zorgt niet voor synchronisatie tussen threads; gebruik het bewust, bijvoorbeeld voor interne hulpstatus, en niet om wijzigingen aan de logische waarde van een object te verbergen.

Dit artikel betreft C++23. Het aangeleverde document is een voortdurend bijgewerkt werkdocument, geen bevroren C++23-tekst. De compileroptie in de verificatieprocedure selecteert C++23; dit bevestigt geen productieomgeving en ook niet dat er een test is uitgevoerd.

Voorbeelden

#include <iostream>

struct Counter {
    mutable int calls = 0;

    int next() const {
        return ++calls;
    }
};

int main() {
    const Counter counter;
    std::cout << counter.next() << ' ' << counter.next() << '\n';

    int seed = 10;
    auto next = [seed]() mutable { return ++seed; };
    std::cout << next() << ' ' << next() << ' ' << seed << '\n';
}

Resultaat

1 2
11 12 10

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen