如何检测成员函数或自由函数为指定类型精确实现而非继承自基类

实现方案 #

以下实现可以满足你需要的「精确检测当前类型自身实现，排除继承成员、隐式转换匹配」的要求，适配序列化/反序列化工具的使用场景：

#include <type_traits>
#include <utility>

// 通用辅助模板：用于阻止隐式类型转换，兼容所有C++版本
template<typename T>
struct type_identity { using type = T; };
template<typename T>
using type_identity_t = typename type_identity<T>::type;

// ==============================================
// 1. 成员函数精确检测：仅T类自身定义了对应签名的Foo时返回true，继承的成员不算
// 可通过修改Sig参数适配不同的函数签名（比如const、带参数等场景）
// ==============================================
template<typename T, typename Sig = void(T::*)(), typename = void>
struct HasMember : std::false_type {};

template<typename T, typename Sig>
struct HasMember<T, Sig, std::void_t<decltype(&T::Foo)>> 
    : std::bool_constant<std::is_same_v<decltype(&T::Foo), Sig>> {};

template<typename T>
constexpr bool HasMember_v = HasMember<T>::value;

// ==============================================
// 2. 自由函数精确检测：仅存在精确匹配T类型参数的Foo重载时返回true，隐式转换匹配不算
// ==============================================
namespace detail {
    // 低优先级 fallback 重载：无用户自定义匹配时才会走到这个分支
    template<typename T>
    void Foo(type_identity_t<T>) = delete;

    template<typename T, typename = void>
    struct HasFreeFooImpl : std::false_type {};

    template<typename T>
    struct HasFreeFooImpl<T, std::void_t<decltype(Foo(std::declval<T>()))>> 
        : std::bool_constant<!std::is_same_v<decltype(Foo(std::declval<T>())), decltype(Foo(type_identity_t<T>{}))>> {};
}

template<typename T>
struct HasFreeFoo : detail::HasFreeFooImpl<T> {};

template<typename T>
constexpr bool HasFreeFoo_v = HasFreeFoo<T>::value;

// ==============================================
// 测试用例
// ==============================================
struct A { void Foo() {} }; 
struct B : A {};
struct C : B {};
                                          
void Foo(const A &) {}
// 额外测试用例
struct D {};
void Foo(const D&) {}
struct E : D {};
struct F { void Foo() const {} }; // 带const的成员函数测试

int main() {
    // 成员函数检测结果完全符合需求
    static_assert(HasMember_v<A> == true);
    static_assert(HasMember_v<C> == false);
    static_assert(HasMember_v<D> == false);
    // 检测带const的成员函数只需传入对应签名即可
    static_assert(HasMember<F, void(F::*)() const>::value == true);

    // 自由函数检测结果完全符合需求
    static_assert(HasFreeFoo_v<A> == true);
    static_assert(HasFreeFoo_v<C> == false);
    static_assert(HasFreeFoo_v<D> == true);
    static_assert(HasFreeFoo_v<E> == false);
}

原理说明 #

1. 成员函数检测逻辑：除了基础的可调用检测外，额外校验&T::Foo的类型是否和我们预期的T类成员函数签名完全一致。如果Foo是从基类继承来的，&T::Foo的实际类型是基类的成员函数指针，和T的成员指针类型不匹配，就会返回false。你可以通过修改第二个模板参数Sig，灵活适配const、带序列化参数等不同的函数签名场景。
2. 自由函数检测逻辑：我们在私有命名空间定义了一个优先级最低的fallback重载，只有当没有用户自定义的、可精确匹配T类型的Foo重载时，编译器才会选择这个fallback。我们通过判断调用结果是否匹配fallback，自动过滤掉通过派生类转基类引用等隐式转换匹配的场景。

如果你需要检测serialize、deserialize等不同名称的函数，只需要把代码里的Foo替换成对应的函数名，或者封装成带函数名参数的宏模板即可。

内容的提问来源于stack exchange，提问作者felix