İşlev şablonunun içindeki işlevi yalnızca işlevi tanımlanmış olan türler için yürüt

Ben girdi olarak birçok farklı türde alır bir işlev şablonu var. Bu tiplerden sadece bir tanesinin bir getInt()işlevi vardır. Bu nedenle, kodun yalnızca bu tür için işlevi çalıştırmasını istiyorum. Lütfen bir çözüm önerin. Teşekkürler

#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);
}

Bir fişlevi getInt, yalnızca işlev değil , işlev üyesi olan tüm türler için çağırabilmek istiyorsanız, işlev için X2 aşırı yük bildirebilirsiniz f:

1. getIntsınıf dahil üye işlevine sahip türler içinX

2. sınıf dahil tüm diğer türler için Y.

C ++ 11 / C ++ 17 çözümü

Bunu aklınızda tutarak, böyle bir şey yapabilirsiniz:

#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);
}

Canlı olarak kontrol edin .

std::void_tC ++ 17'de tanıtıldığını lütfen unutmayın , ancak C ++ 11 ile sınırlıysanız void_t, kendi başınıza uygulamak gerçekten kolaydır :

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

Ve işte C ++ 11 sürümü canlı .

C ++ 20'de ne var?

C ++ 20 birçok iyi şey getirir ve bunlardan biri kavramlardır . C ++ 11 / C ++ 14 / C ++ 17 için geçerli olan yukarıdaki şey C ++ 20'de önemli ölçüde azaltılabilir:

#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);
}

Canlı olarak kontrol edin .

if constexprC ++ 17'den kullanabilirsiniz :

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
    }
    // ...
}

Daha önce, aşırı yükleri ve SFINAE'yi veya etiket gönderimini kullanmanız gerekecek.

Basit ve aşırı yüklenmesini sağlayın. En az C ++ 98'den beri çalıştı ...

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

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

getIntFonksiyonu olan tek bir tip varsa bu yeterlidir . Daha fazlası varsa, artık o kadar basit değil. Bunu yapmanın birkaç yolu var, işte bir tane:

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
}

Tanılama çıkışlı canlı örnek.