Chỉ thực hiện chức năng bên trong mẫu hàm cho những loại có chức năng được xác định

Tôi có một mẫu hàm có nhiều loại khác nhau làm đầu vào. Trong số các loại đó chỉ có một trong số chúng có getInt()chức năng. Do đó tôi muốn mã chỉ chạy chức năng cho loại đó. Xin đề xuất một giải pháp. Cảm ơn

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

Nếu bạn muốn có thể gọi một hàm fcho tất cả các loại có thành viên hàm getInt, không chỉ X, bạn có thể khai báo 2 quá tải cho hàm f:

1. cho các loại có getIntchức năng thành viên, bao gồm cả lớpX

2. cho tất cả các loại khác, bao gồm cả lớp Y.

Giải pháp C ++ 11 / C ++ 17

Có suy nghĩ đó, bạn có thể làm một cái gì đó như thế này:

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

Kiểm tra nó trực tiếp .

Xin lưu ý rằng std::void_tđược giới thiệu trong C ++ 17, nhưng nếu bạn bị giới hạn ở C ++ 11, thì thực sự rất dễ thực hiện void_t:

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

Và đây là phiên bản C ++ 11 trực tiếp .

Chúng ta có gì trong C ++ 20?

C ++ 20 mang lại rất nhiều điều tốt và một trong số đó là các khái niệm . Trên đây là điều hợp lệ cho C ++ 11 / C ++ 14 / C ++ 17 có thể giảm đáng kể trong 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);
}

Kiểm tra nó trực tiếp .

Bạn có thể sử dụng if constexprtừ 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
    }
    // ...
}

Trước đây, bạn sẽ phải sử dụng quá tải và SFINAE hoặc gửi thẻ.

Giữ nó đơn giản và quá tải. Đã làm việc kể từ ít nhất C ++ 98 ...

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

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

Điều này là đủ nếu chỉ có một loại có getIntchức năng. Nếu có nhiều hơn, nó không còn đơn giản nữa. Có một số cách để làm điều đó, đây là một cách:

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
}

Ví dụ sống với đầu ra chẩn đoán.