是否可以在 C++11 中编写宏 existsof(S,f) 或 hasfield(S,f)？

Question

我相当熟悉不涉及宏魔法的标准元编程解决方案（例如C++11 ways of finding if a type has member function or supports operator?）。但是，我有一个涉及以下便利宏的用例（当然，对于 StackOverflow 进行了极大的简化，但想象一下这是用于序列化之类的）......

#define START(type) do { typedef type current; const char typeName[] = #type
#define OUTPUT(fieldname) \
    printf("type of %s.%s is %s\n", #type, #fieldname, \
        std::is_same<decltype(std::declval<current>().fieldname),int> ? "int" : "string")
#define END() } while (0)


struct Foo { int i; char *j; char *k; };
struct Bar { char *x; int y; };

START(Foo);
  OUTPUT(i);  // type of Foo.i is int
  OUTPUT(j);  // type of Foo.j is string
  OUTPUT(k);  // type of Foo.k is string
END();
START(Bar);
  OUTPUT(x);  // type of Bar.x is string
  OUTPUT(y);  // type of Bar.y is int
END();

但是现在假设有人出现并向我们的模式添加了一种新的数据成员：字段对(x, xLength)。我们想像这样更改我们的便利宏...

#define START(obj) do { const auto& current = (obj)
#define OUTPUT(fieldname) \
    printf("type of %s.%s is %s\n", #type, #fieldname, \
        std::is_same<decltype(std::declval<current>().fieldname),int> ? "int" :
        hasfield(current, fieldname##Length) ? "Pascal string" : "C string")
#define END() } while (0)


struct Baz { char *x, *y, *z; int xLength, zLength; };

START(Baz);
  OUTPUT(x);  // type of Baz.x is Pascal string
  OUTPUT(y);  // type of Baz.y is C string
  OUTPUT(z);  // type of Baz.z is Pascal string
END();

我自己设法想出了以下适用于 Clang 的 hasfield 实现......

#define hasfield(classtype, fieldname)                                        \
    []() {                                                                    \
        struct X {                                                            \
            template<class T, int=sizeof(&T::fieldname)> static constexpr bool f(T*){ return true; } \
            static constexpr bool f(...) { return false; }                    \
        }; return X::f((classtype*)0);                                        \
    }()

...但不幸的是，这似乎是由于a bug in Clang；根据 C++11 标准，本地类X 不允许有模板成员。事实上，这段代码无法用 GCC 编译。

所以我被难住了：在 C++11 中可能定义 OUTPUT 宏以便它做我想做的事吗？

绝对约束：不改变Baz的结构定义。无需提前对fieldname 进行硬编码。

Nice-to-haves：一个hasfield(c,f) 宏，也可以在其他上下文中使用（而不是将代码直接缠绕到OUTPUT 宏中）。不假设offsetof(c,fLength)==offsetof(c,f)+sizeof(std::declval<c>().f)。

Answer 1

通过从 current 继承并依赖阴影，可以使其在某些对您可能或可能无关紧要的限制下工作：声明一个本地 fieldname 变量，创建一个从您的类型派生的本地类' 正在检查，并在成员函数内部检查 fieldname 是否仍然引用局部变量。如果是，则不存在成员 fieldname。

#include <utility>
#include <stdio.h>

#define START(type) do { typedef type current; const char typeName[] = #type
#define HASMEMBER(fieldname) \
    []() -> bool { \
        struct HASMEMBER1 { } fieldname; \
        struct HASMEMBER2 : current { \
             static char TEST1(HASMEMBER1&); \
             static char (&TEST1(...))[2]; \
             auto TEST2() -> decltype(TEST1(fieldname)); \
        }; \
        return sizeof(std::declval<HASMEMBER2>().TEST2()) == 2; \
    }()
#define OUTPUT(fieldname) \
    printf("type of %s.%s is %s\n", typeName, #fieldname, \
        std::is_same<decltype(current::fieldname),int>::value ? "int" : \
        HASMEMBER(fieldname##Length) ? "Pascal string" : "C string")
#define END() } while (0)

struct Foo { int i; char *j; char *k; };
struct Bar { char *x; int y; };
struct Baz { char *x, *y, *z; int xLength, zLength; };

int main()
{
START(Foo);
  OUTPUT(i);  // type of Foo.i is int
  OUTPUT(j);  // type of Foo.j is C string
  OUTPUT(k);  // type of Foo.k is C string
END();
START(Bar);
  OUTPUT(x);  // type of Bar.x is C string
  OUTPUT(y);  // type of Bar.y is int
END();
START(Baz);
  OUTPUT(x);  // type of Baz.x is Pascal string
  OUTPUT(y);  // type of Baz.y is C string
  OUTPUT(z);  // type of Baz.z is Pascal string
END();
}

经过编辑以适用于 GCC 4.6.3。它仍然被 GCC 4.8.1 和 clang 3.3 接受，并且应该也适用于 GCC 4.7.3（但不是 4.7.2）。

Answer 2

感谢@hvd the clever idea of looking for either a local variable or an inherited member! 这是我最终在 GCC 4.6.3 上工作的确切代码：

#include <utility>
#include <stdio.h>

#define START(type) do { typedef type current; const char typeName[] = #type
#define HASMEMBER(fieldname) \
    []()->bool { \
        char fieldname; \
        struct HASMEMBER2 : current { \
             auto TEST2() -> char[sizeof(fieldname)]; \
        }; \
        return sizeof(std::declval<HASMEMBER2>().TEST2()) != 1; \
    }()
#define OUTPUT(fieldname) \
    printf("type of %s.%s is %s\n", typeName, #fieldname, \
        std::is_same<decltype(current::fieldname),int>::value ? "int" : \
        HASMEMBER(fieldname##Length) ? "Pascal string" : "C string")
#define END() } while (0)


struct Foo { int i; char *j; char *k; };
struct Bar { char *x; int y; };
struct Baz { char *x, *y, *z; int xLength, zLength; };

int main()
{
START(Foo);
  OUTPUT(i);  // type of Foo.i is int
  OUTPUT(j);  // type of Foo.j is C string
  OUTPUT(k);  // type of Foo.k is C string
END();
START(Bar);
  OUTPUT(x);  // type of Bar.x is C string
  OUTPUT(y);  // type of Bar.y is int
END();
START(Baz);
  OUTPUT(x);  // type of Baz.x is Pascal string
  OUTPUT(y);  // type of Baz.y is C string
  OUTPUT(z);  // type of Baz.z is Pascal string
END();
}

请注意，这种方法无法区分 1 字节长的 char xLength 和缺少 xLength。对于我的申请，这是可以接受的；我所有的 xLength 字段要么长 4 个字节，要么不存在。

请注意，此HASMEMBER 仅适用于非私有成员变量；它不应该用于测试私有成员 (duh) 或成员函数。同样，这对于我的应用程序来说是可以接受的。

根据记录，GCC 4.6.3 存在一些错误，导致它拒绝编译 auto member_func() -> decltype(data_member)，但它对 auto member_func() -> char[sizeof data_member] 很满意。