KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::is_convertible — impliciete conversie testen

std::is_convertible controleert tijdens het compileren of From impliciet naar To kan worden geconverteerd. std::is_convertible_v geeft dezelfde bool-waarde zonder ::value; een positief resultaat garandeert niet dat de waarde behouden blijft of dat er geen uitzonderingen optreden.

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

Syntax

#include <type_traits>

std::is_convertible<From, To>::value
std::is_convertible_v<From, To>

In de header <type_traits> geeft de trait std::is_convertible<From, To> via ::value een bool-constante. De variabeltemplate std::is_convertible_v<From, To> is een verkorte vorm van diezelfde waarde. Eerst komt het brontype, gevolgd door het doeltype.

De test modelleert To test() { return std::declval<From>(); }: hij controleert of de impliciete conversie geldig is, zonder die uit te voeren. De toegang wordt gecontroleerd vanuit een context die geen verband houdt met een van beide typen; alleen de directe context van de expressie telt mee.

Een explicit-constructor is niet voldoende, hoewel std::is_constructible_v<To, From> true kan zijn. Referenties en const zijn van belang. Een resultaat true garandeert niet dat er geen verlies of uitzonderingen zijn.

Zowel voor From als voor To zijn complete typen, void met of zonder cv-kwalificaties en arrays met onbekende grens toegestaan. Geef geen incomplete klasse per waarde door. Aan deze eis voldoen is niet genoeg: als de instantiatie direct of indirect afhangt van een incompleet objecttype en het completeren van dat type het resultaat zou kunnen veranderen, is het gedrag ongedefinieerd. Zo zijn Derived* en Base* complete pointertypen, maar het testen van de conversie van Derived* naar Base* heeft ongedefinieerd gedrag als het completeren van Derived het resultaat kan veranderen.

Het voorbeeld vergelijkt impliciete en explicit-constructors en controleert referentiebinding.

Voorbeelden

#include <iostream>
#include <type_traits>

struct Implicit {
    Implicit(int) {}
};

struct Explicit {
    explicit Explicit(int) {}
};

static_assert(std::is_convertible<int, Implicit>::value);
static_assert(!std::is_convertible_v<int, Explicit>);
static_assert(std::is_constructible_v<Explicit, int>);
static_assert(std::is_convertible_v<int&, const int&>);
static_assert(!std::is_convertible_v<const int&, int&>);

int main() {
    std::cout << std::boolalpha
              << std::is_convertible<int, Implicit>::value << '\n'
              << std::is_convertible_v<int, Explicit> << '\n';
}

Resultaat

true
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.

Bronnen