Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

std::is_convertible — provjera implicitne pretvorbe

std::is_convertible provjerava tijekom kompilacije može li se From implicitno pretvoriti u To. std::is_convertible_v izlaže istu vrijednost bool bez ::value; pozitivan rezultat ne jamči očuvanje vrijednosti ni odsutnost iznimaka.

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

Sintaksa

#include <type_traits>

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

U zaglavlju <type_traits> trait std::is_convertible<From, To> preko ::value izlaže konstantu tipa bool. Predložak varijable std::is_convertible_v<From, To> skraćeni je zapis iste vrijednosti. Prvo se navodi izvorni tip, a zatim odredišni tip.

Test modelira To test() { return std::declval<From>(); }: provjerava je li implicitna pretvorba valjana, a da je pritom ne izvršava. Pristup se provjerava iz konteksta koji nije povezan ni s jednim od ta dva tipa; uzima se u obzir samo neposredni kontekst izraza.

Konstruktor explicit nije dovoljan, iako std::is_constructible_v<To, From> može biti true. Važni su i reference i const. Rezultat true ne jamči da nema gubitaka ni iznimaka.

Za From i To dopušteni su potpuni tipovi, void s kvalifikatorima cv ili bez njih te polja nepoznate granice. Nemojte prosljeđivati nepotpunu klasu po vrijednosti. Ispunjavanje tog zahtjeva nije dovoljno: ako instanciranje izravno ili neizravno ovisi o nepotpunom objektnom tipu, a dovršetak definicije tog tipa mogao bi promijeniti rezultat, ponašanje je nedefinirano. Primjerice, Derived* i Base* potpuni su pokazivački tipovi, ali ponašanje pri provjeri pretvorbe iz Derived* u Base* nedefinirano je ako bi dovršetak definicije Derived mogao promijeniti rezultat.

Primjer uspoređuje implicitne i explicit konstruktore te provjerava vezivanje referenci.

Primjeri

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

Rezultat

true
false

Prikazani kôd i navedeni rezultat provjereni su u izoliranom okruženju metodom zabilježenom u dokazu provjere za ovu točnu verziju.

Izvori