为非 POD 类型寻找类似于 offsetof() 的东西

Question

我正在寻找一种方法来获取具有非 POD 性质的 C++ 类的数据成员的偏移量。

原因如下：

我想以 HDF5 格式存储数据，这似乎最适合我喜欢的材料（数值模拟输出），但它可能是一个相当面向 C 的库。 我想通过 C++ 接口使用它，这需要我像这样声明存储类型（以下文档来自 此处 和此处< /a>（第 4.3.2.1.1 节））：

class example { 
public:
    double member_a;
    int member_b;
} //class example

H5::CompType func_that_creates_example_CompType() {
    H5::CompType ct;
    ct.insertMember("a", HOFFSET(example, member_a), H5::PredType::NATIVE_DOUBLE);
    ct.insertMember("b", HOFFSET(example, member_b), H5::PredType::NATIVE_INT);
    return ct;
} //func_that_creates_example_CompType

其中 HOFFSET 是使用 offsetof 的 HDF 特定宏。

当然，问题是，一旦示例类变得更有特色，它就不再是 POD 类型，因此使用 offsetof 将给出未定义的结果。

我能想到的唯一解决方法是首先将要存储的数据导出到更简单的结构，然后将其传递给 HDF。 然而，这确实涉及数据复制，这正是 HDF 试图避免的（以及为什么他们有这个 CompType，它使库能够访问您的对象以将其数据保存到文件中）。

所以我希望你能有更好的想法。 理想情况下，我会为这个问题寻找一个可移植的解决方法，但如果没有的话，您可以给我一个在 x86 和 x86_64 上使用 GCC 工作的想法，我将非常感激。

----- 稍后追加： -----

Greg Hewgill 下面建议将数据存储在一个简单的结构中，然后通过继承该结构来构建实际的类。 特别是对于 HDF，我认为这实际上可能行不通。 比上面更详细的使用场景：

class base_pod {
public:
    double member_a;
    int member_b;
}; //class base_pod

class derived_non_pod : private base_pod {
public:
    //the following method is only virtual to illustrate the problem
    virtual double get_member_a() {return member_a; }
}; //class derived_non_pod

class that_uses_derived_non_pod {
public:
    void whatever();
private:
    derived_non_pod member_c;
}; //class that_uses_derived_non_pod

现在，当我们存储 that_uses_driven_non_pod 类的实例时，我们无法将其内存布局描述为好像它有一个 base_pod 作为 member_c。 这会使偏移量错误，因为衍生_非_pod添加了一些时髦的东西（我猜像虚拟函数表？）。

Answer 1

Greg Hewgill 的解决方案可能比这个更好（也许使用组合而不是继承）。

然而，我认为对于 x86 和 x86_64 上的 GCC，offsetof 实际上甚至对于非 POD 类型的成员也适用，只要它“有意义”。 例如，它不适用于从虚拟基类继承的成员，因为在 GCC 中这是通过额外的间接实现的。 但是，只要您坚持使用普通的公共单继承，GCC 就会碰巧以某种方式布局您的对象，这意味着每个成员都可以在距对象指针的偏移量处访问，因此 offsetof 实现将给出正确的答案。

当然，这样做的问题是您必须忽略警告，这意味着如果您做了一些不起作用的事情，您将取消引用接近空的指针。 从好的方面来说，问题的原因在运行时可能会很明显。 在负面方面，eeew。

[编辑：我刚刚在 gcc 3.4.4 上对此进行了测试，实际上，当获取从虚拟基类继承的成员的偏移量时，警告已升级为错误。 这很好。 我仍然有点担心 gcc 的未来版本（甚至是 4，我不必提供）会更加严格，并且如果您采用这种方法，您的代码将来可能会停止编译。]

Answer 2

根据您想要的可移植性，您甚至可以在非 POD 类型上使用 offsetof()。 它并不严格一致，但按照 offsetof() 在 gcc 和 MSVC 上实现的方式，它可以在当前版本和最近的版本中与非 POD 类型一起使用。

Answer 3

您可以在基类中声明 POD 类型，然后扩展该类（可能使用 private 继承）以添加附加功能。

更新您的更新：因为 衍生_non_pod 实例也可以被视为 base_pod，因此数据成员的偏移量必须相同。 关于实现，您的编译器在布置 衍生_non_pod 结构时，将在 base_pod 的字段之后分配 vtable 指针。

我突然想到，如果您使用私有继承，编译器可能能够选择对数据字段重新排序。 然而，不太可能这样做，并且将继承设置为受保护或公开将避免这种可能的陷阱。

Answer 4

我很确定罗尔的答案 并考虑onebyone的answer 涵盖了您所问的大部分内容。

struct A
{
  int i;
};

class B: public A
{
public:
  virtual void foo ()
  {
  }
};

int main ()
{
  std::cout << offsetof (B, A::i) << std::endl;
}

对于 g++，上面的输出为 4，如果 B 在基类成员“i”之前有一个 vtable，这就是您所期望的。

即使在存在虚拟基数的情况下，也应该可以手动计算偏移量：

struct A1 {
  int i;
};

struct A2 {
  int j;
};

struct A3 : public virtual A2 {
};

class B: public A1, public A3 {
public:
  virtual void foo () {
  }
};

template <typename MostDerived, typename C, typename M>
ptrdiff_t calcOffset (M C::* member)
{
  MostDerived d;
  return reinterpret_cast<char*> (&(d.*member)) - reinterpret_cast<char*> (&d);
}

int main ()
{
  B b;
  std::cout << calcOffset<B> (&A2::j) << ", " 
            << calcOffset<B> (&A1::i) << std::endl;
}

使用 g++，该程序输出 4 和 8。同样，这与 vtable 一致，因为 B 的第一个成员后跟虚拟基数 A2及其成员“j”。 最后是非虚拟基 A1 及其成员“i”。

关键点是您始终根据最派生的对象计算偏移量，即。 B. 如果成员是私有的，那么您可能需要为每个成员添加“getMyOffset”调用。 此调用将在名称可访问的情况下执行计算。

您可能会发现以下内容也很有用。 我认为将所有这些与您正在为其构建 HDF 类型的对象相关联是很好的：

struct H5MemberDef
{
  const char * member_name;
  ptrdiff_t offset;
  H5PredType h5_type;
};


class B  // ....
{
public:

  // ...

  static H5memberDef memberDef[];
};

H5MemberDef B::memberDef[] = {
  { "i", calcOffset<B> (&A1::i), H5::PredType::NATIVE_INT }
  , { "j", calcOffset<B> (&A2::j), H5::PredType::NATIVE_INT }
  , { 0, 0, H5::PredType::NATIVE_INT }
};

然后您可以通过循环构建 H5type：

H5::CompType func_that_creates_example_CompType(H5MemberDef * pDef) {
  H5::CompType ct;
  while (*pDef->member_name != 0)
  {
    ct.insertMember(pDef->member_name, pDef->offset, pDef->h5_type);
    ++pDef;
  }
  return ct;
}

现在，如果您将一个成员添加到 B 或其基数之一，那么一个简单的添加此表将导致生成正确的 HDF 类型。

Answer 5

问题是，只要您的结构/类不是 extern "C"，C++ 编译器就可以自由地重新排列和优化您的结构/类的布局，因此您最终可能会得到重新排序的结构，具体取决于您的编译器。

有类似 C 行为的预处理器（例如#pragma pack）标志，但它们在大多数情况下不可移植。

Answer 6

使用指向成员的指针代替 offsetof() 可以吗？ 我知道您可能必须进行各种类型的转换才能实际使用指针，因为我猜测 InsertMember 在运行时作用于最后一个参数中指定的类型。

但是使用您当前的解决方案，您已经在使用类型系统了，所以我不确定您是否会在那里丢失任何内容。 除了指向成员的指针的语法很丑陋之外。

Answer 7

这对我来说效果很好，我不明白为什么它不会：

#define myOffset(Class,Member) ({Class o; (size_t)&(o.Member) - (size_t)&o;})