使用SFINAE检测是否存在void返回类型的函数

Question

Here's my situaition. I'm trying to detect if a type has special methods utilized by nlohmann::json , namley to_json . Now I've seen the following solutions for free function checking with SFINAE:

• Checking whether a function (not a method) exists in c++11 via templates

• SFINAE: detect if class has free function

but these methods at least appear to rely on the return type of a function being void or not. in the case of to_json the signature is as follows:

void to_json(json& j, const T& p);

which returns void... thus makes these methods fail (the second doesn't really work regardless since defining a custom wrapper for each type simply is not feasible).

I modified the first method, and as expected:

#include <iostream>
#include <type_traits>
#include "json.hpp"

template<class...> struct voider { using type = void; };
template<class... T> using void_t = typename voider<T...>::type;

    template<class T, class = void>
    struct is_jstreamable : std::false_type{};

    template<class T>
    struct is_jstreamable<T, void_t<decltype(to_json(std::declval<nlohmann::json &>(),
                                             std::declval<T>()))>> : std::true_type {};

struct Foo;

template<typename T>
typename std::enable_if<is_jstreamable<T>::value,
        void>::type
bar(){
    std::cout << "It works!" << std::endl;
};

template<typename T>
typename std::enable_if<!is_jstreamable<T>::value,
        void>::type
bar(){
    std::cout << "It doesn't work!" << std::endl;
}

int main(){
//int does have conversion
    bar<int>();
//foo does not have conversion
    bar<Foo>();
}

it fails to work because its void type, the console returning:

It doesn't work!
It doesn't work!

instead of the expected

It works!
It doesn't work!

I saw a method for determining if the return of a function is void but I'm unsure of how to incorprate that as a solution of my problem

Answer 1

nlohmann::json has multiple ways to convert a given type to json. There is no to_json defined for int , so your type trait is working as specified.

Instead, detect if you can convert the type to a nlohmann::json object:

template <typename T>
using is_jstreamable = std::is_convertible<T, nlohmann::json>;

Live on Godbolt