Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

std::is_convertible — sprawdzanie konwersji niejawnej

std::is_convertible sprawdza podczas kompilacji możliwość niejawnej konwersji z From do To. std::is_convertible_v udostępnia tę samą wartość bool bez zapisu ::value; wynik nie gwarantuje zachowania wartości ani braku wyjątków.

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

Składnia

#include <type_traits>

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

W nagłówku <type_traits> cecha std::is_convertible<From, To> udostępnia stałą ::value typu bool. Szablon zmiennej std::is_convertible_v<From, To> jest skrótem tej samej wartości. Kolejność to typ źródłowy, następnie docelowy.

Test modeluje To test() { return std::declval<From>(); }: bada poprawność niejawnej konwersji bez jej wykonywania. Dostęp sprawdzany jest z kontekstu niezwiązanego z oboma typami; uwzględnia się tylko bezpośredni kontekst wyrażenia.

Konstruktor explicit nie wystarcza, choć std::is_constructible_v<To, From> może być true. Referencje i const mają znaczenie. Wynik true nie gwarantuje bezstratności ani braku wyjątków.

Każdy z argumentów From i To musi być typem kompletnym, typem void z kwalifikatorami cv lub bez nich albo tablicą o nieznanej granicy. Nie używaj niekompletnej klasy przekazanej przez wartość. Spełnienie tego wymogu nie wystarcza: jeśli instancja szablonu zależy bezpośrednio lub pośrednio od niekompletnego typu obiektowego i uzupełnienie tego typu mogłoby zmienić wynik, zachowanie jest niezdefiniowane. Na przykład Derived* i Base* są kompletnymi typami wskaźnikowymi, ale sprawdzenie konwersji z Derived* do Base* ma niezdefiniowane zachowanie, jeśli uzupełnienie definicji Derived mogłoby zmienić wynik.

Przykład porównuje konstruktory niejawny i explicit oraz sprawdza wiązanie referencji.

Przykłady

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

Wynik

true
false

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła