std:: is_convertible, std:: is_nothrow_convertible

Если From или To не являются полными типами, (возможно, cv-квалифицированным) void , или массивом неизвестной границы, поведение не определено.

Если создание экземпляра шаблона выше зависит, прямо или косвенно, от неполного типа, и это создание экземпляра может дать другой результат, если бы этот тип был гипотетически завершен, поведение не определено.

Если программа добавляет специализации для любых шаблонов, описанных на этой странице, поведение не определено.

Шаблон вспомогательной переменной

Возможная реализация

namespace detail
{
    template<class T>
    auto test_returnable(int) -> decltype(
        void(static_cast<T(*)()>(nullptr)), std::true_type{}
    );
    template<class>
    auto test_returnable(...) -> std::false_type;
    template<class From, class To>
    auto test_implicitly_convertible(int) -> decltype(
        void(std::declval<void(&)(To)>()(std::declval<From>())), std::true_type{}
    );
    template<class, class>
    auto test_implicitly_convertible(...) -> std::false_type;
} // namespace detail
template<class From, class To>
struct is_convertible : std::integral_constant<bool,
    (decltype(detail::test_returnable<To>(0))::value &&
     decltype(detail::test_implicitly_convertible<From, To>(0))::value) ||
    (std::is_void<From>::value && std::is_void<To>::value)
> {};

template<class From, class To>
struct is_nothrow_convertible : std::conjunction<std::is_void<From>, std::is_void<To>> {};
template<class From, class To>
    requires
        requires
        {
            static_cast<To(*)()>(nullptr);
            { std::declval<void(&)(To) noexcept>()(std::declval<From>()) } noexcept;
        }
struct is_nothrow_convertible<From, To> : std::true_type {};

Примечания

Дает четко определенные результаты для ссылочных типов, void-типов, массивов и функциональных типов.

В настоящее время стандарт не уточняет, считается ли уничтожение объекта, созданного преобразованием (либо результирующего объекта, либо временного объекта, привязанного к ссылке), частью преобразования. Это описано в LWG issue 3400 .

Все известные реализации рассматривают уничтожение как часть преобразования, как предложено в P0758R1 .

Пример

#include <iomanip>
#include <iostream>
#include <string>
#include <string_view>
#include <type_traits>
class E { public: template<class T> E(T&&) {} };
int main()
{
    class A {};
    class B : public A {};
    class C {};
    class D { public: operator C() { return c; } C c; };
    static_assert(std::is_convertible_v<B*, A*>);
    static_assert(!std::is_convertible_v<A*, B*>);
    static_assert(std::is_convertible_v<D, C>);
    static_assert(!std::is_convertible_v<B*, C*>);
    // Обратите внимание, что конструктор Perfect Forwarding делает класс E
    // "конвертируемым" из всего. Таким образом, A может быть заменен на B, C, D..:
    static_assert(std::is_convertible_v<A, E>);
    static_assert(!std::is_convertible_v<std::string_view, std::string>);
    static_assert(std::is_convertible_v<std::string, std::string_view>);
    auto stringify = []<typename T>(T x)
    {
        if constexpr (std::is_convertible_v<T, std::string> or
                      std::is_convertible_v<T, std::string_view>)
            return x;
        else
            return std::to_string(x);
    };
    using std::operator "" s, std::operator "" sv;
    const char* three = "three";
    std::cout << std::quoted(stringify("one"s)) << ' '
              << std::quoted(stringify("two"sv)) << ' '
              << std::quoted(stringify(three)) << ' '
              << std::quoted(stringify(42)) << ' '
              << std::quoted(stringify(42.0)) << '\n';
}

"one" "two" "three" "42" "42.000000"

Смотрите также