std:: is_convertible, std:: is_nothrow_convertible

Si From ou To n'est pas un type complet, (éventuellement qualifié cv) void , ou un tableau de limite inconnue, le comportement est indéfini.

Si une instanciation d'un template ci-dessus dépend, directement ou indirectement, d'un type incomplet, et que cette instanciation pourrait produire un résultat différent si ce type était hypothétiquement complété, le comportement est indéfini.

Si le programme ajoute des spécialisations pour l'un des modèles décrits sur cette page, le comportement est indéfini.

Modèle de variable d'assistance

Implémentation possible

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 {};

Notes

Donne des résultats bien définis pour les types référence, les types void, les types tableau et les types fonction.

Actuellement, la norme n'a pas spécifié si la destruction de l'objet produit par la conversion (soit un objet résultat, soit un temporaire lié à une référence) est considérée comme faisant partie de la conversion. Ceci est LWG issue 3400 .

Toutes les implémentations connues traitent la destruction comme faisant partie de la conversion, comme proposé dans P0758R1 .

Exemple

#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*>);
    // Notez que le constructeur de transfert parfait rend la classe E
    // "convertible" depuis n'importe quoi. Ainsi, A peut être remplacé par 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"

Voir aussi