Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

std::is_convertible — testovanie implicitnej konverzie

std::is_convertible kontroluje pri kompilácii, či možno From implicitne previesť na To. std::is_convertible_v sprístupňuje rovnakú hodnotu bool bez zápisu ::value; kladný výsledok nezaručuje zachovanie hodnoty ani neprítomnosť výnimiek.

Verzia: 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>

V hlavičke <type_traits> sprístupňuje trait std::is_convertible<From, To> cez ::value konštantu typu bool. Premenná šablóna std::is_convertible_v<From, To> je skráteným zápisom tej istej hodnoty. Najprv sa uvádza zdrojový typ a potom cieľový typ.

Test modeluje To test() { return std::declval<From>(); }: overuje, či je implicitná konverzia platná, bez toho, aby ju vykonal. Prístup sa kontroluje z kontextu nesúvisiaceho so žiadnym z oboch typov; zohľadňuje sa iba bezprostredný kontext výrazu.

Konštruktor explicit nestačí, hoci std::is_constructible_v<To, From> môže byť true. Dôležité sú referencie aj const. Výsledok true nezaručuje bezstratovosť ani neprítomnosť výnimiek.

Pre From aj To sú prípustné úplné typy, void s kvalifikátormi cv aj bez nich a polia s neznámym rozsahom. Neodovzdávajte neúplnú triedu hodnotou. Splnenie tejto požiadavky nestačí: ak inštanciácia priamo alebo nepriamo závisí od neúplného objektového typu a doplnenie jeho definície by mohlo zmeniť výsledok, správanie je nedefinované. Napríklad Derived* a Base* sú úplné ukazovateľové typy, ale test konverzie z Derived* na Base* má nedefinované správanie, ak by doplnenie definície Derived mohlo zmeniť výsledok.

Príklad porovnáva implicitné a explicit konštruktory a overuje naviazanie referencií.

Prí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ýsledok

true
false

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje