Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

std::is_convertible — testování implicitní konverze

std::is_convertible kontroluje při kompilaci, zda lze From implicitně převést na To. std::is_convertible_v zpřístupňuje stejnou hodnotu bool bez zápisu ::value; kladný výsledek nezaručuje zachování hodnoty ani nepřítomnost výjimek.

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

Syntaxe

#include <type_traits>

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

V hlavičce <type_traits> zpřístupňuje trait std::is_convertible<From, To> přes ::value konstantu typu bool. Proměnná šablona std::is_convertible_v<From, To> je zkráceným zápisem téže hodnoty. Nejprve se uvádí zdrojový typ a poté cílový typ.

Test modeluje To test() { return std::declval<From>(); }: ověřuje, zda je implicitní konverze platná, aniž by ji provedl. Přístup se kontroluje z kontextu nesouvisejícího s žádným z obou typů; zohledňuje se pouze bezprostřední kontext výrazu.

Konstruktor explicit nestačí, přestože std::is_constructible_v<To, From> může být true. Záleží na referencích i na const. Výsledek true nezaručuje bezztrátovost ani nepřítomnost výjimek.

Pro From i To jsou povoleny úplné typy, void s kvalifikátory cv i bez nich a pole s neznámým rozsahem. Nepředávejte neúplnou třídu hodnotou. Splnění tohoto požadavku nestačí: pokud instanciace přímo či nepřímo závisí na neúplném objektovém typu a doplnění jeho definice by mohlo změnit výsledek, je chování nedefinované. Například Derived* a Base* jsou úplné ukazatelové typy, ale test konverze z Derived* na Base* má nedefinované chování, pokud by doplnění definice Derived mohlo změnit výsledek.

Příklad porovnává implicitní a explicit konstruktory a ověřuje navázání referencí.

Příklady

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

Výsledek

true
false

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje