向下转换指向成员的指针会导致未定义的行为

Question

我在某处读到，指向派生类成员的指针可以转换为指向其基类成员的指针。当我读到这篇文章时，我聪明的头脑开始思考许多例子，并不断发明无限多种可能性：这样的强制转换是否会导致未定义的行为？

[expr.static.cast]/12：

“指向 cv1 T 类型的 D 成员的指针”类型的纯右值可以是 转换为“指向 cv2 T 类型的 B 成员的指针”类型的纯右值， 其中 D 是完整的类类型，B 是 D 的基类，如果 cv2 是 与 cv1 具有相同的简历资格或更高的简历资格。 [..] 否则，行为未定义。

[注6：虽然B类不需要包含原始成员，但通过指向成员的指针进行间接访问的对象的动态类型必须包含原始成员；参见[expr.mptr.oper]。 ——尾注]。

我想知道，以下强制转换是否会导致 UB 因为它们不是从 D 的“指向成员的指针”强制转换为“指向成员的指针” ” B

struct B { int a; void f(); };
struct D1:B {};
struct D2:B {};

static_cast<int D1::*>(&B::a); // UB? (#1)
static_cast<int D2::*>(&B::a); // UB? (#2)
static_cast<void (D1::*)()>(&B::f); // UB? (#3)
static_cast<void (D2::*)()>(&B::f); // UB? (#4)

int B::*b1 = &D1::a;
int B::*b2 = &D2::a;
static_cast<int D1::*>(b1); // OK? (#5) -- fix of (#1)
static_cast<int D2::*>(b2); // OK? (#6) -- fix of (#2)

void (B::*f1)() = &D1::f;
void (B::*f2)() = &D2::f;
static_cast<void (D1::*)()>(f1); // OK? (#7) -- fix of (#3)
static_cast<void (D2::*)()>(f2); // OK? (#8) -- fix of (#4)

static_cast<int D2::*>(b1); // UB? (#9)
static_cast<int D1::*>(b2); // UB? (#10)
static_cast<void (D2::*)()>(f1); // UB? (#11)
static_cast<void (D1::*)()>(f2); // UB? (#12)

[expr.mptr.oper] /4：

给定这个成员访问表达式E1.*E2，如果E1的动态类型 不包含 E2 引用的成员，行为是 未定义。

struct B { };
struct D : B { int b; void g(); };

B* b = new B;
(b->*static_cast<void(B::*)()>(&D::g))(); // UB? (#13)
b->*static_cast<int B::*>(&D::b);         // UB? (#14)

B *b = new D;
(static_cast<D*>(b)->*(&D::g))(); // OK? (#16) -- fix of (#13)
static_cast<D*>(b)->*(&D::b);     // OK? (#17) -- fix of (#14)

Answer 1

第一个代码段中的 #1 到 #12 都不是 UB，因为它们只是将指向成员的指针从基类转换为派生类。这是隐式转换，甚至不需要显式 static_cast。转换在 [conv.mem] 中描述。您对标准的引用不适用，因为 [expr.static.cast]/4 已经涵盖了隐式转换序列。

由于您引用的原因， #13 和 #14 是 UB，因为您创建的 B 对象是最派生的对象，并且它不' t 包含引用的成员。

#16 和 #17 看起来不错。 static_cast 将产生一个指向 D 对象的指针，因为 b 指向一个 B 对象，该对象是D 对象的基础子对象。