Esegue la funzione nel modello di funzione solo per quei tipi che hanno la funzione definita

Ho un modello di funzione che accetta molti tipi diversi come input. Di questi tipi solo uno ha una getInt()funzione. Quindi voglio che il codice esegua la funzione solo per quel tipo. Si prega di suggerire una soluzione. Grazie

#include <type_traits>
#include <typeinfo>

class X {
    public:
    int getInt(){
        return 9;
    }
};

class Y{

};

template<typename T>
void f(T& v){
    // error: 'class Y' has no member named 'getInt'
    // also tried std::is_same<T, X>::value 
    if(typeid(T).name() == typeid(X).name()){
        int i = v.getInt();// I want this to be called for X only
    }
}

int main(){
    Y y;
    f(y);
}

Se vuoi essere in grado di chiamare una funzione fper tutti i tipi che hanno un membro di funzione getInt, non solo X, puoi dichiarare 2 sovraccarichi per la funzione f:

1. per i tipi con getIntfunzione membro, inclusa la classeX

2. per tutti gli altri tipi, compresa la classe Y.

Soluzione C ++ 11 / C ++ 17

Tenendo presente ciò, potresti fare qualcosa del genere:

#include <iostream>
#include <type_traits>

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

template <typename T>
struct has_getInt<T, std::void_t<decltype(((T*)nullptr)->getInt())>> : std::is_convertible<decltype(((T*)nullptr)->getInt()), int>
{};

class X {
public:
    int getInt(){
        return 9;
    }
};

class Y {};

template <typename T,
          typename std::enable_if<!has_getInt<T>::value, T>::type* = nullptr>
void f(T& v) {
    // only for Y
    std::cout << "Y" << std::endl;
}

template <typename T,
          typename std::enable_if<has_getInt<T>::value, T>::type* = nullptr>
void f(T& v){
    // only for X
    int i = v.getInt();
    std::cout << "X" << std::endl;
}

int main() {
    X x;
    f(x);

    Y y;
    f(y);
}

Dai un'occhiata dal vivo .

Si noti che std::void_tè stato introdotto in C ++ 17, ma se si è limitati a C ++ 11, è davvero facile implementarlo void_tda soli:

template <typename...>
using void_t = void;

Ed ecco la versione C ++ 11 live .

Cosa abbiamo in C ++ 20?

C ++ 20 porta molte cose buone e uno di questi è concetti . Inoltre, ciò che è valido per C ++ 11 / C ++ 14 / C ++ 17 può essere significativamente ridotto in C ++ 20:

#include <iostream>
#include <concepts>

template<typename T>
concept HasGetInt = requires (T& v) { { v.getInt() } -> std::convertible_to<int>; };

class X {
public:
    int getInt(){
        return 9;
    }
};

class Y {};

template <typename T>
void f(T& v) {
    // only for Y
    std::cout << "Y" << std::endl;
}

template <HasGetInt T>
void f(T& v){
    // only for X
    int i = v.getInt();
    std::cout << "X" << std::endl;
}

int main() {
    X x;
    f(x);

    Y y;
    f(y);
}

Dai un'occhiata dal vivo .

È possibile utilizzare if constexprda C ++ 17:

template<typename T>
void f(T& v){
    if constexpr(std::is_same_v<T, X>) { // Or better create trait has_getInt
        int i = v.getInt();// I want this to be called for X only
    }
    // ...
}

Prima, dovrai usare sovraccarichi e SFINAE o invio di tag.

Mantenerlo semplice e sovraccarico. Funziona da almeno C ++ 98 ...

template<typename T>
void f(T& v)
{
    // do whatever
}

void f(X& v)
{
    int result = v.getInt();
}

Questo è sufficiente se esiste un solo tipo con getIntfunzione. Se c'è di più, non è più così semplice. Esistono diversi modi per farlo, eccone uno:

struct PriorityA { };
struct PriorityB : PriorityA { };

template<typename T>
void f_impl(T& t, PriorityA)
{
    // generic version
}

// use expression SFINAE (-> decltype part)
// to enable/disable this overload
template<typename T>
auto f_impl(T& t, PriorityB) -> decltype(t.getInt(), void())
{
    t.getInt();
}

template<typename T>
void f(T& t)
{
    f_impl(t, PriorityB{ } ); // this will select PriorityB overload if it exists in overload set
                              // otherwise PriorityB gets sliced to PriorityA and calls generic version
}

Esempio live con output diagnostico.