함수가 정의 된 유형에 대해서만 함수 템플릿 내에서 함수 실행

입력 할 때 다양한 유형을 취하는 함수 템플릿이 있습니다. 이러한 유형 중 하나만 getInt()기능이 있습니다. 따라서 코드가 해당 유형에 대해서만 함수를 실행하기를 원합니다. 해결책을 제안하십시오. 감사

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

f함수 멤버 getInt가 아닌 모든 멤버에 대해 함수를 호출하려는 경우 함수에 대해 X2 개의 오버로드를 선언 할 수 있습니다 f.

1. getInt클래스를 포함하여 멤버 함수 가있는 유형의 경우X

2. class를 포함한 다른 모든 유형의 경우 Y.

C ++ 11 / C ++ 17 솔루션

이를 염두에두고 다음과 같이 할 수 있습니다.

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

실시간으로 확인하십시오 .

참고하시기 바랍니다 std::void_t당신이 C ++ 11로 제한하는 경우 C ++ (17)에 도입되어 있지만은, 그것은 구현하기 정말 쉽게 void_t자신에 :

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

그리고 여기에 C ++ 11 버전이 있습니다 .

C ++ 20에는 무엇이 있습니까?

C ++ 20은 많은 장점을 제공하며 그중 하나는 개념 입니다. C ++ 11 / C ++ 14 / C ++ 17에 유효한 것은 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);
}

실시간으로 확인하십시오 .

if constexprC ++ 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
    }
    // ...
}

이전에는 과부하 및 SFINAE 또는 태그 디스패치를 ​​사용해야합니다.

간단하고 과부하를 유지하십시오. 적어도 C ++ 98부터 일해 왔습니다 ...

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

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

기능이있는 유형이 하나만 있으면 충분 getInt합니다. 더 있으면 더 이상 간단하지 않습니다. 여러 가지 방법이 있습니다. 여기에 하나가 있습니다.

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
}

진단 출력이 포함 된 라이브 예.