База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

std::is_convertible — проверка на неявно преобразуване

std::is_convertible проверява по време на компилация дали From може да се преобразува неявно в To. std::is_convertible_v предоставя същата стойност bool без ::value; положителният резултат не гарантира запазване на стойността или липса на изключения.

Версия: C++23; repository compiler flag, production runtime not attested

Синтаксис

#include <type_traits>

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

В заглавния файл <type_traits> trait-ът std::is_convertible<From, To> предоставя константа от тип bool чрез ::value. Шаблонът на променлива std::is_convertible_v<From, To> е съкратен запис на същата стойност. Първо е типът източник, следван от типа цел.

Тестът моделира To test() { return std::declval<From>(); }: проверява дали неявното преобразуване е валидно, без да го извършва. Достъпът се проверява от контекст, несвързан с нито един от двата типа; взема се предвид само непосредственият контекст на израза.

Конструктор explicit не е достатъчен, въпреки че std::is_constructible_v<To, From> може да е true. Референциите и const имат значение. Резултат true не гарантира нито липса на загуба, нито липса на изключения.

За From и To са допустими завършени типове, void със или без cv-квалификатори и масиви с неизвестна граница. Не подавайте незавършен клас по стойност. Спазването на това изискване не е достатъчно: ако инстанцирането зависи пряко или косвено от незавършен обектен тип и завършването на този тип би могло да промени резултата, поведението е неопределено. Например Derived* и Base* са завършени указателни типове, но поведението при проверка на преобразуването от Derived* към Base* е неопределено, ако завършването на дефиницията на Derived би могло да промени резултата.

Примерът сравнява неявни и explicit конструктори и проверява свързването на референции.

Примери

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

Резултат

true
false

Показаният код и заявеният резултат са проверени в изолирана среда по метода, записан в доказателството за проверка на тази точна версия.

Източници