我找到了类似this one之类的问题和答案。但是，正如我尝试的那样，如果测试成员直接在被测试的类中定义，则此SFINAE测试仅成功。例如，以下类B，D1打印HAS，而其他两个打印NOT HAS。有没有办法确定一个类是否有一个成员，它是由它自己定义，还是一个基类，并且在这种情况下不知道基类的名称。我的动机是，我想编写一个泛型函数，如果它存在，将调用某个特定的方法（从基础或非基础，参数的类型是通用的，留下其可能基础的类型）。
#include <iostream>
class HasFoo
{
public :
typedef char Small;
typedef struct {char; char;} Large;
template <typename C, void (C::*) ()> class SFINAE {};
template <typename C> static Small test (SFINAE<C, &C::foo> *)
{
std::cout << "HAS" << std::endl;
}
template <typename C> static Large test (...)
{
std::cout << "NOT HAS" << std::endl;
}
};
class B
{
public :
void foo () {}
};
class D1 : public B
{
public :
void foo () {} // overide
};
class D2 : public B
{
public :
using B::foo;
};
class D3 : public B {};
int main ()
{
HasFoo::test<B>(0);
HasFoo::test<D1>(0);
HasFoo::test<D2>(0);
HasFoo::test<D3>(0);
}
答案 0 :(得分：8)
在C ++ 03中，遗憾的是这不可能，抱歉。
在C ++ 11中，由于decltype的魔力，事情变得更容易 。 decltype允许您编写表达式来推断其结果的类型，因此您可以完美地命名基类的成员。如果方法是模板，则SFINAE适用于decltype表达式。
#include <iostream>
template <typename T>
auto has_foo(T& t) -> decltype(t.foo(), bool()) { return true; }
bool has_foo(...) { return false; }
struct Base {
void foo() {}
};
struct Derived1: Base {
void foo() {}
};
struct Derived2: Base {
using Base::foo;
};
struct Derived3: Base {
};
int main() {
Base b; Derived1 d1; Derived2 d2; Derived3 d3;
std::cout << has_foo(b) << " "
<< has_foo(d1) << " "
<< has_foo(d2) << " "
<< has_foo(d3) << "\n";
}
不幸的是，ideone有一个版本的gcc，这个版本太旧了，而clang 3.0并不是更好。
答案 1 :(得分：3)
不幸的是，至少在C ++ 03中是不可能的，我也怀疑C ++ 11。
几点重要：
public private和protected继承了SFINAE
可能最终没用了public方法/继承，
可以增强代码HasFoo::test<>以获取多个代码
基类也可以传递的参数;
std::is_base_of<>可用于进一步验证
基础/派生关系;然后对基类应用相同的逻辑
也答案 2 :(得分：3)
有一种方法可以确定类层次结构是否具有给定名称的成员。它使用SFINAE并通过创建歧义在名称查找中引入替代失败。此外，有一种方法可以测试公共成员是否可以调用;但是，无法确定成员是否公开SFINAE。
Here就是一个例子：
#include <iostream>
template < typename T >
struct has_foo
{
typedef char yes;
typedef char no[2];
// Type that has a member with the name that will be checked.
struct fallback { int foo; };
// Type that will inherit from both T and mixin to guarantee that mixed_type
// has the desired member. If T::foo exists, then &mixed_type::foo will be
// ambiguous. Otherwise, if T::foo does not exists, then &mixed_type::foo
// will successfully resolve to fallback::foo.
struct mixed_type: T, fallback {};
template < typename U, U > struct type_check {};
// If substituation does not fail, then &U::foo is not ambiguous, indicating
// that mixed_type only has one member named foo (i.e. fallback::foo).
template < typename U > static no& test( type_check< int (fallback::*),
&U::foo >* = 0 );
// Substituation failed, so &U::foo is ambiguous, indicating that mixed_type
// has multiple members named foo. Thus, T::foo exists.
template < typename U > static yes& test( ... );
static const bool value = sizeof( yes ) ==
sizeof( test< mixed_type >( NULL ) );
};
namespace detail {
class yes {};
class no{ yes m[2]; };
// sizeof will be used to determine what function is selected given an
// expression. An overloaded comma operator will be used to branch based
// on types at compile-time.
// With ( helper, anything-other-than-no, yes ) return yes.
// With ( helper, no, yes ) return no.
struct helper {};
// Return helper.
template < typename T > helper operator,( helper, const T& );
// Overloads.
yes operator,( helper, yes ); // For ( helper, yes ) return yes.
no operator,( helper, no ); // For ( helper, no ) return no.
no operator,( no, yes ); // For ( no, yes ) return no.
} // namespace detail
template < typename T >
struct can_call_foo
{
struct fallback { ::detail::no foo( ... ) const; };
// Type that will inherit from T and fallback, this guarantees
// that mixed_type has a foo method.
struct mixed_type: T, fallback
{
using T::foo;
using fallback::foo;
};
// U has a foo member.
template < typename U, bool = has_foo< U >::value >
struct impl
{
// Create the type sequence.
// - Start with helper to guarantee the custom comma operator is used.
// - This is evaluationg the expression, not executing, so cast null
// to a mixed_type pointer, then invoke foo. If T::foo is selected,
// then the comma operator returns helper. Otherwise, fooback::foo
// is selected, and the comma operator returns no.
// - Either helper or no was returned from the first comma operator
// evaluation. If ( helper, yes ) remains, then yes will be returned.
// Otherwise, ( no, yes ) remains; thus no will be returned.
static const bool value = sizeof( ::detail::yes ) ==
sizeof( ::detail::helper(),
((mixed_type*)0)->foo(),
::detail::yes() );
};
// U does not have a 'foo' member.
template < typename U >
struct impl< U, false >
{
static const bool value = false;
};
static const bool value = impl< T >::value;
};
// Types containing a foo member function.
struct B { void foo(); };
struct D1: B { bool foo(); }; // hide B::foo
struct D2: B { using B::foo; }; // no-op, as no hiding occured.
struct D3: B { };
// Type that do not have a member foo function.
struct F {};
// Type that has foo but it is not callable via T::foo().
struct G { int foo; };
struct G1 { bool foo( int ); };
int main ()
{
std::cout << "B: " << has_foo< B >::value << " - "
<< can_call_foo< B >::value << "\n"
<< "D1: " << has_foo< D1 >::value << " - "
<< can_call_foo< D1 >::value << "\n"
<< "D2: " << has_foo< D2 >::value << " - "
<< can_call_foo< D2 >::value << "\n"
<< "D3: " << has_foo< D3 >::value << " - "
<< can_call_foo< D3 >::value << "\n"
<< "F: " << has_foo< F >::value << " - "
<< can_call_foo< F >::value << "\n"
<< "G: " << has_foo< G >::value << " - "
<< can_call_foo< G >::value << "\n"
<< "G1: " << has_foo< G1 >::value << " - "
<< can_call_foo< G1 >::value << "\n"
<< std::endl;
return 0;
}
产生以下输出：
B: 1 - 1 D1: 1 - 1 D2: 1 - 1 D3: 1 - 1 F: 0 - 0 G: 1 - 0 G1: 1 - 0
has_foo仅检查是否存在名为foo的成员。它不验证foo是否是可调用成员（公共成员函数或作为仿函数的公共成员）。
can_call_foo检查T::foo()是否可调用。如果T::foo()不公开，则会发生编译器错误。据我所知，没有办法通过SFINAE来阻止这种情况。要获得更完整，更出色但相当复杂的解决方案，请查看here。