Question

是否有可能有一个成员变量，能够从指向自身的指针计算指向包含对象的指针（在它的方法中）？

让我们在API中包含一个外部调用接口，如下所示：

template <typename Class, MethodId Id, typename Signature>
class MethodProxy;

template <typename Class, MethodId Id, typename ReturnT, typename Arg1T>
class MethodProxy<Class, Id, ReturnT ()(Arg1T) {
  public:
    ReturnT operator()(Class &invocant, Arg1T arg1);
};

并且类似地从0到N的其他数量的参数。对于外来的每个类，一个C ++类被声明具有一些特征，并且该模板使用这些特征（以及参数类型的更多特征）来查找和调用外国方法。这可以像：

一样使用

Foo foo;
MethodProxy<Foo, barId, void ()(int)> bar;
bar(foo, 5);

现在我想做的是以这种方式定义Foo，我可以这样称呼：

Foo foo;
foo.bar(5);

多次不重复签名。（显然创建一个静态成员并在方法中包装调用很简单，对吧）。嗯，事实上，这仍然很容易：

template <typename Class, MethodId Id, typename Signature>
class MethodMember;
template <typename Class, MethodId Id, typename ReturnT, typename Arg1T>
class MethodMember<Class, Id, ReturnT ()(Arg1T) {
    MethodProxy<Class, Id, Signature> method;
    Class &owner;
  public:
    MethodMember(Class &owner) : owner(owner) {}
    ReturnT operator()(Arg1T arg1) { return method(owner, arg1); }
};

然而，这意味着该对象最终将包含许多指向自身的指针副本。所以我正在寻找一种方法，使这些实例能够计算this的所有者指针和一些额外的模板参数。

我正在思考

template <typename Class, size_t Offset, ...>
class Member {
    Class *owner() {
        return reinterpret_cast<Class *>(
            reinterpret_cast<char *>(this) - Offset);
    }
    ...
};
class Foo {
    Member<Foo, offsetof(Foo, member), ...> member;
    ...
};

但是这抱怨Foo在这一点上是不完整的类型。

是的，我知道offsetof应该仅适用于“POD”类型，但实际上对于任何非虚拟成员都是有效的。我同样试图在该参数中传递指向（也就是）成员（使用伪基类），但这也不起作用。

请注意，如果这样做，它也可以用于实现委托给包含类的方法的类似C＃的属性。

我知道如何使用boost.preprocessor来执行上面提到的包装器方法，但是参数列表必须以奇怪的形式指定。我知道如何编写宏来通过模板生成通用包装器，但这可能会导致很差的诊断。如果呼叫看起来像foo.bar()(5)，那也是微不足道的。但是我想知道是否有一些聪明的技巧是可能的（加上只有这样聪明的技巧才可能用于属性）。

注意：成员类型实际上不能专门指向它的成员指针或它的偏移量，因为在分配该偏移量之前必须知道该类型。那是因为类型会影响所需的对齐（考虑显式/ parcial特化）。

Answer 1

提出问题是实现答案的最佳方式，所以这就是我所拥有的：

偏移量不能是模板参数，因为必须先知道类型才能计算偏移量。所以它必须由参数的函数返回。让我们添加一个标签类型（虚拟结构），并将一个重载函数放入Owner或直接放入标签。这样我们就可以在一个地方定义我们需要的一切（使用宏）。以下代码使用gcc 4.4.5进行编译，并为所有成员打印正确的指针：

#include <cstddef>
#include <iostream>

using namespace std;

（只是让它真正编译的序言）

template <typename Owner, typename Tag>
struct offset_aware
{
    Owner *owner()
    {
        return reinterpret_cast<Owner *>(
            reinterpret_cast<char *>(this) - Tag::offset());
    }
};

这是让对象意识到它自己的偏移所需要的。可以自由添加属性或仿函数或其他代码以使其有用。现在我们需要声明一些额外的东西以及成员本身，所以让我们定义这个宏：

#define OFFSET_AWARE(Owner, name) \
    struct name ## _tag { \
        static ptrdiff_t offset() { \
            return offsetof(Owner, name); \
        } \
    }; \
    offset_aware<Owner, name ## _tag> name

这将结构定义为标记，并放入一个返回所需偏移量的函数。比它定义数据成员本身。

请注意，该成员需要公开，如此处所定义，但我们可以轻松地为标记支持受保护和私有属性添加“朋友”声明。现在让我们使用它。

struct foo
{
    int x;
    OFFSET_AWARE(foo, a);
    OFFSET_AWARE(foo, b);
    OFFSET_AWARE(foo, c);
    int y;
};

简单，不是吗？

int main()
{
    foo f;

    cout << "foo f = " << &f << endl
        << "f.a: owner = " << f.a.owner() << endl
        << "f.b: owner = " << f.b.owner() << endl
        << "f.c: owner = " << f.c.owner() << endl;
    return 0;
}

这会在所有行上打印相同的指针值。 C ++标准不允许成员具有0大小，但是它们只有实际内容的大小或1个字节（如果它们是空的，而不是指针的4或8个（取决于平台）字节。

Answer 2

1）有一个gcc扩展似乎合适：

enum{ d_y = __builtin_choose_expr(N,offsetof(X,y),0) };

但它并没有像预期的那样发挥作用，尽管手册中说 “内置函数不会评估未选择的表达式”

2）成员指针似乎很有趣，例如。 offsetof可以这样定义：

template< class C, class T >
int f( T C::*q ) {
  return (int)&((*(C*)0).*q);
}

但我仍然没有办法将其变成constexpr。

3）现在，这是另一个版本：

#include <stdio.h>

#pragma pack(1)

template <class A, int x>
struct B {
  int z;
  void f( void ) {
    printf( "x=%i\n", x );
  }
};

#define STRUCT( A ) template< int N=0 > struct A {
#define CHILD( A, N, B, y ) }; template<> struct A<N> : A<N-1> \
  { B<A<N>,sizeof(A<N-1>)> y;
#define STREND };

STRUCT( A )
  int x0;
  int x1;
  CHILD( A,1, B, y );
  short x2;
  CHILD( A,2, B, z );
  char x3;
STREND

typedef A<2> A1;

int main( void ) {
  A1 a;
  a.y.f();
  a.z.f();
}

Answer 3

目前，这是一个特定于MS的解决方案，仍然在考虑如何使其更加通用

#include <stdio.h>

#define offs(s,m)   (size_t)&(((s *)0)->m)
#define Child(A,B,y) \
  __if_exists(X::y) { enum{ d_##y=offs(X,y) }; } \
  __if_not_exists(X::y) { enum{ d_##y=0 }; } \
  B<A,d_##y> y;

template <class A, int x>
struct B {
  int z;
  void f( void ) {
    printf( "x=%i\n", x );
  }
};

template< class X >
struct A {
  int x0;
  int x1;
  Child(A,B,y);
  Child(A,B,z);
};

typedef A<int> A0;

typedef A<A0> A1;

int main( void ) {
  A1 a;
  a.y.f();
  a.z.f();
}

Answer 4

假设调用实际上需要对包含对象的引用，只需将引用存储到所有者。除非你有特定的内存分析证据表明它会导致显着的内存增加来存储额外的引用，否则就这么做了。

知道自己的偏移量的C ++类成员变量

4 个答案: