Início / coding / Perguntas / 79565569
Accepted
Biggy Smith
Asked: 2025-04-10 09:25:59 +0800 CST

C++ detectando sobrecarga de função sem conversões

  • 772

Tenho um monte de sobrecargas de funções, consistindo principalmente em duas assinaturas:

void func(const my_type1&);  
void func(const my_type2&, hash_t);

e uma função que tenta chamar func com base na existência da função:

template <typename T>
void func_imp(const T& t, hash_t hash){
    if constexpr (has_func_with_2nd_param_v<T>){
        func(t, hash);
    }else{
        func(t);
    }
}

mas estou tendo problemas de conversão que acabam chamando a sobrecarga 'errada':

#include <type_traits>
#include <cstdio>

struct hash_t{
};

struct my_type1{
    my_type1() {}
};

struct my_type2{
    my_type2() {}
    my_type2(const my_type1&){}
};

void func(const my_type1&){
    printf("no hash\n");
}

void func(const my_type2&, hash_t=hash_t()){
    printf("hash\n");
}

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

template<typename T>
struct has_func_with_2nd_param<T, std::void_t<decltype(func(std::declval<T>(), std::declval<hash_t>()))>> : std::true_type {};

template<typename T>
constexpr bool has_func_with_2nd_param_v = has_func_with_2nd_param<T>::value;

// I want to route to the appropriate function without conversion routing to the wrong func
template <typename T>
void func_imp(const T& t, hash_t hash){
    if constexpr (has_func_with_2nd_param_v<T>){
        func(t, hash);
    }else{
        func(t);
    }
}

int main()
{
    // this is true as expected
    static_assert(has_func_with_2nd_param_v<my_type2>);

    // this is also true, since my_type2 is constructable from my_type1 and then finds finds func(my_type2, hash_t)
    static_assert(has_func_with_2nd_param_v<my_type1>);

    func_imp(my_type1(), hash_t()); // prints "hash", but wanting it to call the "no hash" version
    func_imp(my_type2(), hash_t()); // prints "hash"

    return 0;
}

Estou com dificuldades para encontrar a metafunção correta para obter o comportamento desejado. Alguém tem alguma ideia?

godbolt aqui

c++

1 respostas

  1. Best Answer

    Você pode usar a regra que permite, no máximo, uma conversão de tipo definida pelo usuário e adicionar um tipo fictício que imponha outra conversão de tipo definida pelo usuário. Dessa forma, você precisará ter uma correspondência exata de tipo para os tipos originais.

    template <typename T>
struct ForceExactClassType{
    operator const T&() const;
};

    A struct ForceExactClassTypeé usada apenas para impor uma conversão definida pelo usuário em contextos não avaliados, portanto, uma definição para operator const T&()não é necessária. Você pode precisar ajustar as partes conste &dependendo das suas necessidades, mas o mecanismo subjacente é o mesmo.

    Para impor a conversão extra, a característica do tipo deve ser alterada para

    template<typename T>
struct has_func_with_2nd_param<T, std::void_t<decltype(func(std::declval<ForceExactClassType<T>>(), std::declval<hash_t>()))>> : std::true_type {};

    Então, pelo menos para o exemplo que você mostrou, ele se comporta como esperado.

    Saídas:

    no hash
hash

    Até certo ponto, a is_exactly_invocablecaracterística que você mencionou em um comentário a uma resposta agora excluída pode ser implementada como

    template <typename Fn, typename... ArgTypes>
struct is_exactly_invocable: std::is_invocable<Fn, ForceExactClassType<ArgTypes>...>
{};

    Observe que isso tem a limitação de funcionar apenas para tipos de classe. Não funcionaria para tipos que podem ser convertidos implicitamente sem passar por uma função de conversão definida pelo usuário. Também não funcionaria se Fnfosse um functor que tivesse um modelo, operator()pois conversões não são consideradas nas deduções de parâmetros de modelo (apontado em um comentário de @ Jarod42 ).

    Com a característica geral definida acima, as seguintes afirmações são válidas:

    static_assert(is_exactly_invocable<void(const my_type2&, hash_t), my_type2, hash_t>::value);
static_assert(!is_exactly_invocable<void(const my_type2&, hash_t), my_type1, hash_t>::value);

    Demonstração: https://godbolt.org/z/Kqr1n14b6

    • 4

relate perguntas