比较成员指针

Question

我阅读了有关内置比较运算符的信息。我想知道为什么成员指针没有排序运算符（<、<=、>、>=）。比较结构实例化的两个成员的地址是有效的。

http://en.cppreference.com/w/cpp/language/operator_comparison:

3) 如果在一个非联合类类型的对象中，两个指针指向具有相同成员访问权限的不同非静态数据成员，或者指向这些成员的子对象或数组元素，则递归地指向后者的指针声明的成员比较大。换句话说，三种成员访问模式中的每一种中的类成员都是按照声明的顺序在内存中定位的。

使用 adressof 运算符 (&) 和成员指针解引用运算符 (.*) 可以比较地址，但需要一个实例。

我的问题：

1. 为什么没有用于成员指针的内置排序运算符？

2. 如何在没有实例的情况下比较两个成员指针？

我的方法：

#include <iostream>

    template<class S, class T>
int cmp_memberptr(T S::* a, T S::* b) {
    //S s; // works, but needed instanciation
    //S& s = std::declval<S>(); // error
    S& s = *(S*)nullptr; // no instanciation, works (on my machine), but undefined behavior because of nullptr dereference (most compilers warn directly)!

    // note: the precedence of .*:
    return int(&(s.*a) < &(s.*b)) - int(&(s.*a) > &(s.*b));
};

struct Point { int x, y; };

int main(int argc, char const* const* argv) {

    Point p;

    #define tst(t) std::cout << #t " is " << ((t) ? "true" : "false") << '\n'

    tst(&p.x < &p.y);
    //tst(&Point::x < &Point::y); // the main problem!
    tst(cmp_memberptr(&Point::x, &Point::y) < 0);

    #undef tst
};

我考虑过offsetof-macro，但它没有将成员指针作为参数。

Answer 1

我不知道这是如何符合标准的，但是根据Godbolt，以下代码在 clang、gcc 和 MSVC 中干净地编译，并以有效的方式生成正确的代码（基本上，对于 m2，push 4） ：

#include "stdio.h"

template <typename T, typename M> int member_offset (M m)
{
    const void *pv = nullptr;
    const T *pT = static_cast <const T *> (pv);
    return static_cast <int> (reinterpret_cast <const char *> (&(pT->*m)) - reinterpret_cast <const char *> (pT));
}

class x
{
 public:
    int m1;
    int m2;
};

int main (void)
{
    int m1_offset = member_offset <x> (&x::m1);
    int m2_offset = member_offset <x> (&x::m2);
    printf ("m1_offset=%d, m2_offset=%d\n", m1_offset, m2_offset);
}

来自Wandbox的输出：

Start
m1_offset=0, m2_offset=4
0
Finish

现在您可以使用或比较 member_offset's 来做任何您想做的事情。

编辑

正如上面 Caleth 和 Deduplicator 所指出的，这不适用于虚拟继承。有关原因，请参阅我对 Deduplicator 答案的最后评论。顺便说一句，我很感兴趣的是，在使用虚拟继承时访问基类中的实例变量时存在显着的运行时开销。我没有意识到这一点。

此外，以下简单的宏更易于使用，并且可以与 clang 的多重继承一起正常工作（对于所有那些花哨的模板来说就是如此）：

#define member_offset(classname, member) \
    ((int) ((char *) &((classname*) nullptr)->member - (char *) nullptr))

您可以在Wandbox 使用 gcc 和 clang 进行测试：

#include "stdio.h"

#define member_offset(classname, member) \
        ((int) ((char *) &((classname *) nullptr)->member - (char *) nullptr))

struct a { int m1; };
struct b { int m2; };
struct c : a, b { int m3; };

int main (void)
{
    int m1_offset = member_offset (c, m1);
    int m2 = member_offset (c, m2);
    int m3 = member_offset (c, m3);
    printf ("m1_offset=%d, m2=%d, m3=%d\n", m1_offset, m2, m3);
}

输出：

m1_offset=0, m2=4, m3=8

但是，如果您将此宏与使用虚拟继承的类一起使用，您会得到一个 SEGFAULT（因为编译器需要查看对象内部以找到该对象的数据成员的偏移量并且那里没有对象 - 只是一个 nullptr )。

因此，OP 问题的答案是，在一般情况下，您确实需要一个实例来执行此操作。也许有一个特殊的构造函数，它什么都不做，以最小的开销创建其中之一。

第二次编辑

我想了更多，然后我想到了，而不是说：

int mo = member_offset (c, m);

你应该说：

constexpr int mo = member_offset (c, m);

如果类 c 使用虚拟继承，编译器会提醒你。

不幸的是，clang 和 gcc 都不会为任何类型的类编译它，无论是否虚拟继承。另一方面，MSVC 会产生编译器错误，并且只会在 c 类使用虚拟继承时产生编译器错误。

我不知道哪个编译器在这里做正确的事情，就标准而言，但 MSVC 的行为显然是最明智的。

Answer 2

成员指针比你想象的更复杂。它们由一个指向潜在存在的 vtable 的索引和一个偏移量组成（MSVC 在这方面被破坏了，但没有指定额外的选项）。

这是由于虚拟继承的存在，这意味着虚拟基础子对象的确切偏移量取决于最派生的类型，而不是用于访问的静态类型。
甚至虚拟基地的顺序也取决于此。

因此，您可以为指向同一虚拟基础的元素或指向任何虚拟基础之外的元素的成员指针创建一个总顺序。任何特定的实现甚至可能要求更多（接受强制的低效率），但这超出了标准的范围。

最后，在不了解实现细节和额外保证的情况下，您甚至不能依赖总订单。

Example on coliru:

#include <iostream>

struct B {
    int x;
};
struct M : virtual B {};
struct D : M {
    int y;
};

static void print_offset(const M& m) {
    std::cout << "offset of m.x: " << ((char*)&m.x - (char*)&m) << '\n';
}

int main() {
    print_offset(M{});
    print_offset(D{});
}

示例输出：

offset of m.x: 8
offset of m.x: 12