Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

std::is_convertible — preverjanje implicitne pretvorbe

std::is_convertible med prevajanjem preveri, ali je mogoče From implicitno pretvoriti v To. std::is_convertible_v razkrije isto vrednost bool brez ::value; pozitiven rezultat ne zagotavlja ohranitve vrednosti ali odsotnosti izjem.

Različica: 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>

V glavi <type_traits> lastnost std::is_convertible<From, To> prek ::value razkrije konstanto tipa bool. Spremenljivčna predloga std::is_convertible_v<From, To> je krajši zapis iste vrednosti. Najprej je naveden izvorni tip, nato ciljni tip.

Preizkus modelira To test() { return std::declval<From>(); }: preveri, ali je implicitna pretvorba veljavna, ne da bi jo izvedel. Dostop se preverja iz konteksta, ki ni povezan z nobenim od obeh tipov; upošteva se samo neposredni kontekst izraza.

Konstruktor explicit ne zadostuje, čeprav je lahko std::is_constructible_v<To, From> enak true. Pomembni so sklici in const. Rezultat true ne zagotavlja, da ni izgub ali izjem.

Za From in To so dovoljeni popolni tipi, void s kvalifikatorji cv ali brez njih ter polja z neznano mejo. Nepopolnega razreda ne posredujte po vrednosti. Izpolnitev te zahteve ne zadostuje: če je instanciacija neposredno ali posredno odvisna od nepopolnega objektnega tipa in bi dokončanje njegove definicije lahko spremenilo rezultat, je vedenje nedefinirano. Na primer, Derived* in Base* sta popolna kazalčna tipa, vendar je vedenje pri preverjanju pretvorbe iz Derived* v Base* nedefinirano, če bi dokončanje definicije Derived lahko spremenilo rezultat.

Primer primerja implicitne in explicit konstruktorje ter preveri vezavo sklicev.

Primeri

#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

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri