member function exact signature matching

signature_detection.cpp

#include <type_traits>
#include <functional>

//

struct validator
{
    template <template <class...> class, class...>
    static auto constexpr is_valid(...)
    -> std::false_type;

    template <template <class...> class Op, class... Args, class = Op<Args...>>
    static auto constexpr is_valid(int)
    -> std::true_type;
};

template <template <class...> class Op, class... Args>
using is_valid = decltype(validator::is_valid<Op, Args...>(int{}));

template <template <class...> class Op, class... Args>
auto constexpr is_valid_v = is_valid<Op, Args...>::value;

//

template <class T, class Sig>
using has_func = decltype(std::mem_fn<Sig>(&T::func));

template <class T>
struct base
{
    constexpr base()
    {
        static_assert(is_valid_v<has_func, T, void()>);
        static_assert(is_valid_v<has_func, T, int(double)>);
        static_assert(is_valid_v<has_func, T, double(int)>);
        static_assert(is_valid_v<has_func, T, void(int, int)>);
        static_assert(!is_valid_v<has_func, T, void(int)>);

        static_assert(is_valid_v<has_func, T, void() const>);
        static_assert(is_valid_v<has_func, T, int(double) const>);
        static_assert(is_valid_v<has_func, T, double(int) const>);
        static_assert(is_valid_v<has_func, T, void(int, int) const>);
        static_assert(!is_valid_v<has_func, T, void(int) const>);
    }
};

template <template <class> class T>
struct derived : public T<derived<T>>
{
    using base_t = T<derived<T>>;
    friend struct validator;

public:
    void func() {}
    void func() const {}

    void func(int, int) {}
    void func(int, int) const {}

protected:
    int func(double) {}
    int func(double) const {}

private:
    double func(int) {}
    double func(int) const {}
};

//

int main()
{
    volatile auto constexpr test = derived<base>{};
}