76

为了创建算法模板函数，我需要知道作为模板参数的类中的 x 或 X（以及 y 或 Y）。在将我的函数用于 MFC CPoint 类或 GDI+ PointF 类或其他一些类时，它可能很有用。他们都在其中使用不同的 x。我的解决方案可以简化为以下代码：


template<int> struct TT {typedef int type;};
template<class P> bool Check_x(P p, typename TT<sizeof(&P::x)>::type b = 0) { return true; }
template<class P> bool Check_x(P p, typename TT<sizeof(&P::X)>::type b = 0) { return false; }

struct P1 {int x; };
struct P2 {float X; };
// it also could be struct P3 {unknown_type X; };

int main()
{
    P1 p1 = {1};
    P2 p2 = {1};

    Check_x(p1); // must return true
    Check_x(p2); // must return false

    return 0;
}

但它不能在 Visual Studio 中编译，而在 GNU C++ 中编译。使用 Visual Studio，我可以使用以下模板：


template<class P> bool Check_x(P p, typename TT<&P::x==&P::x>::type b = 0) { return true; }
template<class P> bool Check_x(P p, typename TT<&P::X==&P::X>::type b = 0) { return false; }

但它不能在 GNU C++ 中编译。有通用的解决方案吗？

UPD：此处的结构 P1 和 P2 仅作为示例。可能有任何具有未知成员的类。

PS 请不要在此处发布 C++11 解决方案，因为它们很明显且与问题无关。

4

10 回答 10

117

这是一个比 Johannes Schaub-litb的解决方案更简单的解决方案。它需要 C++11。

#include <type_traits>

template <typename T, typename = int>
struct HasX : std::false_type { };

template <typename T>
struct HasX <T, decltype((void) T::x, 0)> : std::true_type { };

更新：一个简单的例子和​​它是如何工作的解释。

对于这些类型：

struct A { int x; };
struct B { int y; };

我们有HasX<A>::value == true和HasX<B>::value == false。让我们看看为什么。

首先回想一下，std::false_type并且std::true_type有一个static constexpr bool名为的成员分别value设置为false和true。因此，上面的两个模板HasX继承了这个成员。（第一个模板来自std::false_type，第二个模板来自std::true_type。）

让我们从简单开始，然后逐步进行，直到我们得到上面的代码。

1) 起点：

template <typename T, typename U>
struct HasX : std::false_type { };

在这种情况下，并不奇怪：HasX派生自std::false_typeand 因此HasX<bool, double>::value == falseand HasX<bool, int>::value == false。

2) 违约U：

// Primary template
template <typename T, typename U = int>
struct HasX : std::false_type { };

鉴于U默认为int,Has<bool>实际上意味着HasX<bool, int>, 因此HasX<bool>::value == HasX<bool, int>::value == false.

3）添加专业：

// Primary template
template <typename T, typename U = int>
struct HasX : std::false_type { };

// Specialization for U = int
template <typename T>
struct HasX<T, int> : std::true_type { };

通常，由于主模板，HasX<T, U>派生自std::false_type. 但是，存在一个U = int衍生自的专业化std::true_type。因此，HasX<bool, double>::value == false但是HasX<bool, int>::value == true。

感谢 , 的默认U设置HasX<bool>::value == HasX<bool, int>::value == true。

4）decltype和一种花哨的说法int：

这里有点题外话，但请多多包涵。

基本上（这并不完全正确），decltype(expression)产生 表达式的类型。例如，0有类型int因此，decltype(0)意味着int。类似地，1.2有类型double，因此，decltype(1.2)意味着double。

考虑一个具有此声明的函数：

char func(foo, int);

foo一些类类型在哪里。如果f是类型的对象foo，则decltype(func(f, 0))表示char（返回的类型func(f, 0)）。

现在，表达式(1.2, 0)使用（内置）逗号运算符按顺序计算两个子表达式（即 first1.2和 then 0），丢弃第一个值并产生第二个值。因此，

int x = (1.2, 0);

相当于

int x = 0;

把它和它放在一起decltype给出了那个decltype(1.2, 0)意思int。这里没有什么特别1.2的double。例如，true也有类型bool和decltype(true, 0)手段int。

类类型呢？例如，这是什么decltype(f, 0)意思？很自然地期望这仍然意味着int，但可能并非如此。实际上，逗号运算符可能存在重载，类似于func上面的函数，它接受 afoo和 anint并返回 a char。在这种情况下，decltype(foo, 0)是char。

我们如何避免对逗号运算符使用重载？好吧，没有办法为操作数重载逗号运算符void，我们可以将任何内容强制转换为void. 因此，decltype((void) f, 0)意味着int。实际上，从to (void) fwhich的转换基本上什么也不做，只是说必须将表达式视为具有 type 。然后使用内置的运算符逗号，结果是which has type 。因此，意味着。ffoovoidvoid((void) f, 0)0intdecltype((void) f, 0)int

这个演员阵容真的有必要吗？好吧，如果逗号运算符没有过载，foo那么int这不是必需的。我们总是可以检查源代码，看看是否有这样的操作符。但是，如果它出现在模板中并且f具有V作为模板参数的类型，则不再清楚（甚至不可能知道）逗号运算符的这种重载是否存在。为了通用，我们无论如何都会投射。

底线：decltype((void) f, 0)是一种花哨的说法int。

5）SFINAE：

这是一门完整的科学；-) 好吧，我在夸大其词，但这也不是很简单。所以我会把解释保持在最低限度。

SFINAE 代表替换失败不是错误。这意味着当模板参数被类型替换时，可能会出现非法 C++ 代码，但在某些情况下，编译器不会中止编译，而是简单地忽略有问题的代码，就好像它不存在一样。让我们看看它如何应用于我们的案例：

// Primary template
template <typename T, typename U = int>
struct HasX : std::false_type { };

// Specialization for U = int
template <typename T>
struct HasX <T, decltype((void) T::x, 0)> : std::true_type { };

再次，这里decltype((void) T::x, 0)是一种奇特的说法，int但得益于 SFINAE。

当T用类型替换时，可能会出现无效的构造。例如，bool::x不是有效的 C++，因此T用boolin替换会T::x产生无效的构造。在 SFINAE 原则下，编译器不会拒绝代码，它只是忽略（部分）它。更准确地说，正如我们所看到的，HasX<bool>实际上是指HasX<bool, int>。U = int应该选择for 的特化，但是在实例化它时，编译器会找到bool::x并完全忽略模板特化，就好像它不存在一样。

此时，代码与上面仅存在主模板的情况 (2) 基本相同。因此，HasX<bool, int>::value == false。

bool用于自成立B以来的相同参数B::x是无效的构造（B没有成员x）。但是，A::x没关系，编译器在实例化 for U = int（或更准确地说， for U = decltype((void) A::x, 0)）的专门化方面没有任何问题。因此，HasX<A>::value == true。

6) 取名U：

好吧，再次查看 (5) 中的代码，我们看到该名称U没有在任何地方使用，而是在其声明 ( typename U) 中使用。然后我们可以取消第二个模板参数的名称，并获得本文顶部显示的代码。

于 2013-04-14T14:38:05.717 回答
53

另一种方式是这种方式，它也依赖于SFINAE 的表达式。如果名称查找导致歧义，编译器将拒绝该模板

template<typename T> struct HasX { 
    struct Fallback { int x; }; // introduce member name "x"
    struct Derived : T, Fallback { };

    template<typename C, C> struct ChT; 

    template<typename C> static char (&f(ChT<int Fallback::*, &C::x>*))[1]; 
    template<typename C> static char (&f(...))[2]; 

    static bool const value = sizeof(f<Derived>(0)) == 2;
}; 

struct A { int x; };
struct B { int X; };

int main() { 
    std::cout << HasX<A>::value << std::endl; // 1
    std::cout << HasX<B>::value << std::endl; // 0
}

它基于usenet 上某人的一个绝妙想法。

注意：HasX 检查任何名为 x 的数据或函数成员，具有任意类型。引入成员名称的唯一目的是为成员名称查找提供可能的歧义 - 成员的类型并不重要。

于 2009-06-17T13:52:37.303 回答
34

我从一个问题被重定向到这里，该问题已作为该问题的副本关闭。我知道这是一个旧线程，但我只是想建议一个可用于 C++11 的替代（更简单？）实现。假设我们要检查某个类是否有一个名为的成员变量id：

#include <type_traits>

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

template<typename T>
struct has_id<T, decltype(std::declval<T>().id, void())> : std::true_type { };

就是这样。以下是它的使用方式（现场示例）：

#include <iostream>

using namespace std;

struct X { int id; };
struct Y { int foo; };

int main()
{
    cout << boolalpha;
    cout << has_id<X>::value << endl;
    cout << has_id<Y>::value << endl;
}

使用几个宏可以使事情变得更加简单：

#define DEFINE_MEMBER_CHECKER(member) \
    template<typename T, typename V = bool> \
    struct has_ ## member : false_type { }; \
    template<typename T> \
    struct has_ ## member<T, \
        typename enable_if< \
            !is_same<decltype(declval<T>().member), void>::value, \
            bool \
            >::type \
        > : true_type { };

#define HAS_MEMBER(C, member) \
    has_ ## member<C>::value

可以这样使用：

using namespace std;

struct X { int id; };
struct Y { int foo; };

DEFINE_MEMBER_CHECKER(foo)

int main()
{
    cout << boolalpha;
    cout << HAS_MEMBER(X, foo) << endl;
    cout << HAS_MEMBER(Y, foo) << endl;
}
于 2013-01-25T14:27:20.203 回答
6

更新：我最近对我在原始答案中发布的代码做了更多的事情，所以我正在更新它以考虑更改/添加。

以下是一些用法片段： *所有这些的胆量都在更远的地方

检查x给定类中的成员。可以是 var、func、class、union 或 enum：

CREATE_MEMBER_CHECK(x);
bool has_x = has_member_x<class_to_check_for_x>::value;

检查成员函数void x()：

//Func signature MUST have T as template variable here... simpler this way :\
CREATE_MEMBER_FUNC_SIG_CHECK(x, void (T::*)(), void__x);
bool has_func_sig_void__x = has_member_func_void__x<class_to_check_for_x>::value;

检查成员变量x：

CREATE_MEMBER_VAR_CHECK(x);
bool has_var_x = has_member_var_x<class_to_check_for_x>::value;

检查成员类x：

CREATE_MEMBER_CLASS_CHECK(x);
bool has_class_x = has_member_class_x<class_to_check_for_x>::value;

检查会员工会x：

CREATE_MEMBER_UNION_CHECK(x);
bool has_union_x = has_member_union_x<class_to_check_for_x>::value;

检查成员枚举x：

CREATE_MEMBER_ENUM_CHECK(x);
bool has_enum_x = has_member_enum_x<class_to_check_for_x>::value;

x无论签名如何，检查任何成员函数：

CREATE_MEMBER_CHECK(x);
CREATE_MEMBER_VAR_CHECK(x);
CREATE_MEMBER_CLASS_CHECK(x);
CREATE_MEMBER_UNION_CHECK(x);
CREATE_MEMBER_ENUM_CHECK(x);
CREATE_MEMBER_FUNC_CHECK(x);
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value;

或者

CREATE_MEMBER_CHECKS(x);  //Just stamps out the same macro calls as above.
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value;

细节和核心：

/*
    - Multiple inheritance forces ambiguity of member names.
    - SFINAE is used to make aliases to member names.
    - Expression SFINAE is used in just one generic has_member that can accept
      any alias we pass it.
*/

template <typename... Args> struct ambiguate : public Args... {};

template<typename A, typename = void>
struct got_type : std::false_type {};

template<typename A>
struct got_type<A> : std::true_type {
    typedef A type;
};

template<typename T, T>
struct sig_check : std::true_type {};

template<typename Alias, typename AmbiguitySeed>
struct has_member {
    template<typename C> static char ((&f(decltype(&C::value))))[1];
    template<typename C> static char ((&f(...)))[2];

    //Make sure the member name is consistently spelled the same.
    static_assert(
        (sizeof(f<AmbiguitySeed>(0)) == 1)
        , "Member name specified in AmbiguitySeed is different from member name specified in Alias, or wrong Alias/AmbiguitySeed has been specified."
    );

    static bool const value = sizeof(f<Alias>(0)) == 2;
};

宏（暗黑破坏神！）：

CREATE_MEMBER_CHECK：

//Check for any member with given name, whether var, func, class, union, enum.
#define CREATE_MEMBER_CHECK(member)                                         \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct Alias_##member;                                                      \
                                                                            \
template<typename T>                                                        \
struct Alias_##member <                                                     \
    T, std::integral_constant<bool, got_type<decltype(&T::member)>::value>  \
> { static const decltype(&T::member) value; };                             \
                                                                            \
struct AmbiguitySeed_##member { char member; };                             \
                                                                            \
template<typename T>                                                        \
struct has_member_##member {                                                \
    static const bool value                                                 \
        = has_member<                                                       \
            Alias_##member<ambiguate<T, AmbiguitySeed_##member>>            \
            , Alias_##member<AmbiguitySeed_##member>                        \
        >::value                                                            \
    ;                                                                       \
}

CREATE_MEMBER_VAR_CHECK：

//Check for member variable with given name.
#define CREATE_MEMBER_VAR_CHECK(var_name)                                   \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct has_member_var_##var_name : std::false_type {};                      \
                                                                            \
template<typename T>                                                        \
struct has_member_var_##var_name<                                           \
    T                                                                       \
    , std::integral_constant<                                               \
        bool                                                                \
        , !std::is_member_function_pointer<decltype(&T::var_name)>::value   \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_FUNC_SIG_CHECK：

//Check for member function with given name AND signature.
#define CREATE_MEMBER_FUNC_SIG_CHECK(func_name, func_sig, templ_postfix)    \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct has_member_func_##templ_postfix : std::false_type {};                \
                                                                            \
template<typename T>                                                        \
struct has_member_func_##templ_postfix<                                     \
    T, std::integral_constant<                                              \
        bool                                                                \
        , sig_check<func_sig, &T::func_name>::value                         \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_CLASS_CHECK：

//Check for member class with given name.
#define CREATE_MEMBER_CLASS_CHECK(class_name)               \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_class_##class_name : std::false_type {};  \
                                                            \
template<typename T>                                        \
struct has_member_class_##class_name<                       \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_class<                                    \
            typename got_type<typename T::class_name>::type \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_UNION_CHECK：

//Check for member union with given name.
#define CREATE_MEMBER_UNION_CHECK(union_name)               \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_union_##union_name : std::false_type {};  \
                                                            \
template<typename T>                                        \
struct has_member_union_##union_name<                       \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_union<                                    \
            typename got_type<typename T::union_name>::type \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_ENUM_CHECK：

//Check for member enum with given name.
#define CREATE_MEMBER_ENUM_CHECK(enum_name)                 \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_enum_##enum_name : std::false_type {};    \
                                                            \
template<typename T>                                        \
struct has_member_enum_##enum_name<                         \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_enum<                                     \
            typename got_type<typename T::enum_name>::type  \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_FUNC_CHECK：

//Check for function with given name, any signature.
#define CREATE_MEMBER_FUNC_CHECK(func)          \
template<typename T>                            \
struct has_member_func_##func {                 \
    static const bool value                     \
        = has_member_##func<T>::value           \
        && !has_member_var_##func<T>::value     \
        && !has_member_class_##func<T>::value   \
        && !has_member_union_##func<T>::value   \
        && !has_member_enum_##func<T>::value    \
    ;                                           \
}

CREATE_MEMBER_CHECKS：

//Create all the checks for one member.  Does NOT include func sig checks.
#define CREATE_MEMBER_CHECKS(member)    \
CREATE_MEMBER_CHECK(member);            \
CREATE_MEMBER_VAR_CHECK(member);        \
CREATE_MEMBER_CLASS_CHECK(member);      \
CREATE_MEMBER_UNION_CHECK(member);      \
CREATE_MEMBER_ENUM_CHECK(member);       \
CREATE_MEMBER_FUNC_CHECK(member)
于 2011-06-12T21:49:30.870 回答
4

Boost.ConceptTraits提供了一些宏来定义类型特征，例如BOOST_TT_EXT_DEFINE_HAS_MEMBER(name)，它定义了以下形式的类型特征：

has_member_##name<T>

如果 T 有一个名为 的成员类型，则为真。但是请注意，这不会检测到引用类型成员。

在您的情况下，添加头文件就足够了

BOOST_TT_EXT_DEFINE_HAS_MEMBER_TYPE(x)

并检查如下

BOOST_STATIC_ASSERT(has_member_x<P1>::value);

使用的技术与前面一些答案中解释的技术相同。

不幸的是，这个库不再维护。现在 C++0x 将不包含概念，这个库与 SFINAE 一起是处理大多数概念的完美替代品。

于 2010-04-22T20:09:22.440 回答
3

你为什么不使用这样的专业化：

struct P1 {int x; };
struct P2 {int X; };

template<class P> 
bool Check_x(P p) { return true; }

template<> 
bool Check_x<P2>(P2 p) { return false; }
于 2009-06-17T07:20:36.987 回答
3

我们可以使用C++20 的 requires 表达式来解决这个问题。h/t 致@lefticus，他最近在C++ Weekly - Ep 242 - Design By Introspection in C++20 中发布了此方法（概念 + if constexpr：

#include <iostream>

struct P1 {int x;};
struct P2 {float X;};

bool has_x(const auto &obj) {
    if constexpr (requires {obj.x;}) {
      return true;
    } else
      return false;
}

int main()
{
    P1 p1 = {1};
    P2 p2 = {1};

    std::cout << std::boolalpha << has_x(p1) << "\n"; 
    std::cout << has_x(p2) << "\n"; 

    return 0;
}

你可以在这里看到它。

于 2020-10-19T18:50:58.573 回答
1

为什么不直接创建 Check_x 的模板特化？

template<> bool Check_x(P1 p) { return true; }
template<> bool Check_x(P2 p) { return false; }

哎呀，当我想到它的时候。如果你只有两种类型，为什么还需要模板呢？

于 2009-06-17T07:22:33.113 回答
1

函数 (x, X, y, Y) 是来自抽象基类，还是可以重构为这样？如果是这样，您可以使用 Modern C++ Design 中的 SUPERSUBCLASS() 宏，以及来自这个问题的答案的想法：

基于编译时类型的调度

于 2009-06-17T10:13:20.400 回答
0

我们可以在编译时得到：0 - not_member, 1 - is_object, 2 - is_function对于每个需要的类和成员-对象或函数：http: //ideone.com/Fjm9u5

#include <iostream>
#include <type_traits>

#define IS_MEMBER(T1, M)    \
struct {        \
    struct verystrangename1 { bool M; };    \
    template<typename T> struct verystrangename2 : verystrangename1, public T { }; \
    \
    enum return_t { not_member, is_object, is_function }; \
    template<typename T, typename = decltype(verystrangename2<T>::M)> constexpr return_t what_member() { return not_member;  }  \
    template<typename T> typename std::enable_if<std::is_member_object_pointer<decltype(&T::M)>::value, return_t>::type constexpr what_member() { return is_object; }   \
    template<typename T> typename std::enable_if<std::is_member_function_pointer<decltype(&T::M)>::value, return_t>::type constexpr what_member() { return is_function; }   \
    constexpr operator return_t() { return what_member<T1>(); } \
}

struct t {
    int aaa;
    float bbb;
    void func() {}
};

// Can't be in function
IS_MEMBER(t, aaa) is_aaa_member_of_t;
IS_MEMBER(t, ccc) is_ccc_member_of_t;
IS_MEMBER(t, func) is_func_member_of_t;

// known at compile time
enum { const_is_aaa_member_of_t = (int)is_aaa_member_of_t };
static constexpr int const_is_func_member_of_t = is_func_member_of_t;

int main() {        
    std::cout << std::boolalpha << "0 - not_member, 1 - is_object, 2 - is_function \n\n" <<
        "is aaa member of t = " << is_aaa_member_of_t << std::endl << 
        "is ccc member of t = " << is_ccc_member_of_t << std::endl << 
        "is func member of t = " << is_func_member_of_t << std::endl << 
        std::endl;

    return 0;
}

结果：

0 - not_member, 1 - is_object, 2 - is_function 

is aaa member of t = 1
is ccc member of t = 0
is func member of t = 2

对于类/结构：

struct t {
    int aaa;
    float bbb;
    void func() {}
};
于 2016-07-27T12:56:27.823 回答