Início / coding / Perguntas / 79594192
Accepted
zhanginou
Asked: 2025-04-27 01:12:29 +0800 CST

Traço de tipo para verificar se uma função pode ser compilada com um determinado tipo

  • 772

Tenho dois tipos, CustomNotCompatibleWithRun, CustomCompatibleWithRun, e uma run()função:

#include <iostream>
#include <type_traits>

template <typename T_>
struct CustomNotCompatibleWithRun { using T = T_; };

template <typename T_>
struct CustomCompatibleWithRun {
    using T = T_; 
    
    CustomCompatibleWithRun operator+(const CustomCompatibleWithRun& other)
    {
        CustomCompatibleWithRun res;
        res.a = a + other.a;
        res.b = b + other.b;
        return res;
    }
    
    void print() const
    {
        std::cout << "a, b = " << a << ", " << b << "\n";
    }
    
    T a;
    T b;
};

template <typename T>
T run(T a, T b) { return a+b; }

Quero escrever uma característica de tipo, IsTypeCompatibleWithRun, que verifica se um dado Type(cujo único contrato é ter um alias de tipo Type::T) pode ser usado na run()função. Ou seja:

int main() {
    using T = float;
    CustomCompatibleWithRun<T> obj1{.a = 1.f, .b = 2.f};
    CustomCompatibleWithRun<T> obj2{.a = 2.f, .b = 3.f};
    obj1.print(); // a, b = 1, 2
    obj2.print(); // a, b = 2, 3
    const auto obj3 = obj1 + obj2;
    obj3.print(); // a, b = 3, 5
    const auto obj4 = run(obj1, obj2);
    obj4.print(); // a, b = 3, 5
    CustomNotCompatibleWithRun<T> obj5{};
    CustomNotCompatibleWithRun<T> obj6{};
    // const auto obj7 = obj5 + obj6; // does not compile
    
    std::cout << "IsTypeCompatibleWithRun<CustomCompatibleWithRun>::value: " << IsTypeCompatibleWithRun<CustomCompatibleWithRun<T>>::value << "\n"; // should print 1
    std::cout << "IsTypeCompatibleWithRun<CustomNotCompatibleWithRun>::value: " << IsTypeCompatibleWithRun<CustomNotCompatibleWithRun<T>>::value << "\n"; // should print 0
}

Tentei as três opções abaixo:

template <typename Type, typename = void>
struct IsTypeCompatibleWithRun : std::false_type {};

// Option 1
template <typename Type>
struct IsTypeCompatibleWithRun<Type, decltype(void(run<typename Type::T>(std::declval<typename Type::T>(), std::declval<typename Type::T>())))> : std::true_type {};

// Option 2
template <typename Type>
struct IsTypeCompatibleWithRun<Type, decltype(void(std::declval<Type>() + std::declval<Type>()))> : std::true_type {};

// Option 3
template <typename Type>
struct IsTypeCompatibleWithRun<Type, std::void_t<decltype(run(std::declval<Type>(), std::declval<Type>()))>> : std::true_type {};

E apenas a Opção 2 funciona — pelo que entendi, isso ocorre porque forçamos o +operador dentro da própria característica de tipo, enquanto nas Opções 1 e 3, apenas a assinatura da run()função é verificada. No entanto, estou insatisfeito com a Opção 2 porque ela exige a repetição do corpo da função run()na própria característica de tipo. Neste exemplo simples, funciona bem, mas na minha aplicação, o corpo da run()função é muito mais complexo e é impossível repeti-lo dentro da característica de tipo.

Então tentei mudar a assinatura de run()para

template <typename T>
auto run(T a, T b)

mas o código nem compilava mais. Então tentei adicionar um tipo de retorno final

template <typename T>
auto run(T a, T b) -> decltype(a+b)

e agora a Opção 3 funcionaria, mas não a Opção 1. Por que isso?

De qualquer forma, o acima envolveria ter que repetir a a+bparte no tipo de retorno final, então não é uma solução para mim.

Existe uma maneira de obter esse traço de tipo sem alterar run()e depender apenas run()(e não repetir) seu corpo de função em C++ 14?

c++

2 respostas

  1. Best Answer

    O que você está vendo é uma limitação do SFINAE (Substitution Failure Is Not An Error) no C++14. Isso verifica apenas a assinatura da função durante a substituição do modelo, não o corpo da função, se isso fizer sentido.

    Sem mudar run()e sem repetir seu corpo, não há como atingir esse tipo de característica.

    Espero que isso ajude

    • 1

  2. Para complementar um pouco a sua pergunta à resposta do Alex acima,
    essa limitação pode ser superada em C++ 20, com conceitos. O que significa que é definitivamente possível em C++ 14, usando option1, E usando std::enable_if<> na declaração de run() para restringir ainda mais o acesso a run(). Ficaria um pouco confuso em C++ 14, mas pode ser feito funcionar.

    Exemplo:

    #include <iostream>
#include <type_traits>

// these will help to reduce clutter a bit
template <typename... Ts>
struct make_void {
    typedef void type;
};
template <typename... Ts>
using void_t = typename make_void<Ts...>::type;

// inner_type compatibility type_traits
template <typename T, typename = void>
struct can_add : std::false_type {};

template <typename T>
struct can_add<T,
               std::enable_if_t<std::is_same<
                   T, decltype(std::declval<T>() + std::declval<T>())>::value>>
    : std::true_type {};

// outer type compatibility type_traits
template <typename T, typename = void>
struct has_typedef_t : std::false_type {};

template <typename T>
struct has_typedef_t<T, void_t<typename T::T>> : std::true_type {};

template <typename T, typename = void>
struct has_run : std::false_type {};

template <typename T>
struct has_run<T, void_t<decltype(std::declval<T>().run(std::declval<T>()))>>
    : std::true_type {};

template <typename T>
struct is_run_compatible
    : std::integral_constant<bool,
                             has_typedef_t<T>::value && has_run<T>::value> {};

// types under test
struct bogus {};

template <typename Type>
struct not_compatible {
    using T = Type;
};

template <typename Type>
struct compatible {
    using T = Type;

    // here is the correct place to chack for compatibility with Type.
    template <typename R = std::enable_if<can_add<Type>::value, compatible>>
    typename R::type run(const compatible& a) {
        return compatible{val_ + a.val_};
    }

    Type val_;
};

int main() {
    compatible<int> a;
    compatible<int> b;
    auto c = a.run(b);

    std::cout << "can_add<int>: " << can_add<int>::value << std::endl;
    std::cout << "can_add<float>: " << can_add<float>::value << std::endl;
    std::cout << "can_add<bogus>: " << can_add<bogus>::value << std::endl;

    std::cout << "has_typedef_t<int>" << has_typedef_t<int>::value << std::endl;
    std::cout << "has_typedef_t<not_compatible<int>>"
              << has_typedef_t<not_compatible<int>>::value << std::endl;
    std::cout << "has_typedef_t<compatible<bogus>>"
              << has_typedef_t<compatible<bogus>>::value << std::endl;
    std::cout << "has_typedef_t<compatible<int>>"
              << has_typedef_t<compatible<int>>::value << std::endl;

    std::cout << "has_run<int>" << has_run<int>::value << std::endl;
    std::cout << "has_run<not_compatible<int>>"
              << has_run<not_compatible<int>>::value << std::endl;
    std::cout << "has_run<compatible<bogus>>"
              << has_run<compatible<bogus>>::value << std::endl;
    std::cout << "has_run<compatible<int>>" << has_run<compatible<int>>::value
              << std::endl;

    std::cout << "is_run_compatible<int>" << has_run<int>::value << std::endl;
    std::cout << "is_run_compatible<not_compatible<int>>"
              << is_run_compatible<not_compatible<int>>::value << std::endl;
    std::cout << "is_run_compatible<compatible<bogus>>"
              << is_run_compatible<compatible<bogus>>::value << std::endl;
    std::cout << "is_run_compatible<compatible<int>>"
              << is_run_compatible<compatible<int>>::value << std::endl;
}

    Saída do programa:

    can_add<int>: 1
can_add<float>: 1
can_add<bogus>: 0
has_typedef_t<int>0
has_typedef_t<not_compatible<int>>1
has_typedef_t<compatible<bogus>>1
has_typedef_t<compatible<int>>1
has_run<int>0
has_run<not_compatible<int>>0
has_run<compatible<bogus>>0
has_run<compatible<int>>1
is_run_compatible<int>0
is_run_compatible<not_compatible<int>>0
is_run_compatible<compatible<bogus>>0
is_run_compatible<compatible<int>>1

    Como alternativa, você pode verificar a funcionalidade no nível da classe:

    template <typename Type, typename = std::enable_if_t<can_add<Type>::value>>
struct compatible {
    using T = Type;

    // here is the correct place to chack for compatibility with Type.
    compatible run(const compatible& a) { return compatible{val_ + a.val_}; }

    Type val_;
};

    Você pode brincar com este código aqui: https://godbolt.org/z/vnWd6vcnc

    • 0

relate perguntas