CKTIS / C++
explicit — impliciete conversies beheersen
De specificator explicit beperkt het gebruik van constructors en conversiefuncties bij impliciete conversies, terwijl je objecten nog steeds bewust kunt aanmaken. Leer het verschil tussen directe initialisatie en initialisatie met kopiëren, de bijzondere rol van operator bool en explicit(condition).
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
explicit ClassName(parameters);
explicit operator TargetType() const;
explicit(condition) ClassName(parameters);
explicit(condition) operator TargetType() const;explicit helpt onbedoelde door de gebruiker gedefinieerde conversies te beperken. Het kan een constructor of conversiefunctie binnen een klassedefinitie markeren; het is geen specificator voor gewone functies. Het kan ook voorkomen bij deductiegidsen voor klassentemplates. explicit zonder voorwaarde betekent explicit(true).
Voor een constructor explicit Count(int) zijn zowel Count a(3); als Count b{3}; geldige directe initialisaties. Count c = 3; is ongeldig, omdat initialisatie met kopiëren die constructor niet voor de conversie gebruikt. Count d = {3}; is ook ongeldig als initialisatie met een lijst en kopiëren een explicit-constructor kiest. Een functie die een Count aanneemt, kan evenmin zomaar 3 accepteren, maar kan wel Count{3} ontvangen. De specificator is niet beperkt tot constructors met één parameter.
Een conversiefunctie explicit operator bool() const verbiedt bool e = a;, maar staat static_cast<bool>(a) en directe initialisatie bool e(a); toe. Booleaanse voorwaarden vormen een belangrijke uitzondering: if (a) kan deze operator gebruiken, omdat de contextuele conversie naar bool controleert of directe initialisatie mogelijk is. Dit maakt impliciete conversies niet in het algemeen mogelijk.
In C++23 gelden voor explicit(condition) strengere regels dan voor een gewone if-voorwaarde: het resultaat van de contextuele conversie naar bool moet een constante expressie zijn, en de conversiereeks mag alleen toegestane conversies bevatten, dus geen vernauwende conversies. Zo is 2 een constante expressie en werkt die als voorwaarde in if (2), maar is explicit(2) ongeldig omdat de conversie van 2 naar bool vernauwend is. De waarde true schakelt explicit in; bij false is de declaratie niet expliciet. Dit is geen schakelaar die tijdens uitvoering werkt. Het is nuttig in templates wanneer de impliciete converteerbaarheid afhangt van het type. Het voorbeeld gebruikt de C++23-modus. De bronnen tonen een evoluerend werkdocument, geen vastgelegde C++23-publicatie.
Voorbeelden
#include <iostream>
#include <type_traits>
struct Count {
int value;
explicit Count(int n) : value(n) {}
explicit operator bool() const { return value != 0; }
};
static_assert(std::is_constructible_v<Count, int>);
static_assert(!std::is_convertible_v<int, Count>);
static_assert(!std::is_convertible_v<Count, bool>);
int main() {
Count a(3);
Count b{0};
// Count c = 3;
// Count d = {3};
// bool e = a;
if (a) {
std::cout << a.value << '\n';
}
std::cout << std::boolalpha << static_cast<bool>(b) << '\n';
}
Resultaat
3 false
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.