更改指针时 C++ 指针中断

Question

当我更改 union 中的指针时，我的其他指针会中断并显示无效指针。
自定义数据类型示例类:

struct CustomDataTypeExample {
float x;
float y;
float z;
CustomDataTypeExample() = default;
CustomDataTypeExample(float x, float y, float z) {

    this->x = x;
    this->y = y;
    this->z = z;

};

// ...
};

ConfigCustomDataTypeExample 类:

struct ConfigCustomDataTypeExample {
public:
    ConfigCustomDataTypeExample() = default;
    ConfigCustomDataTypeExample(CustomDataTypeExample values) {
        x = &values.x;
        y = &values.y;
        z = &values.z;
    }
    union {
        struct {

            CustomDataTypeExample* ex;
        };
        struct {

            float* x;
            float* y;
            float* z;
        };
    };
};

主要的:

ConfigCustomDataTypeExample example({ 1.2f,3.4f,5.6f });
float value = 565;
example.x = &value;
std::cout << example.ex->x << ", " << example.ex->y << ", " << example.ex->z << "\n";
std::cout << *example.x << ", " << *example.y << ", " << *example.z << "\n";

输出:

565, -1.07374e+08, -1.07374e+08
565, 3.4, 5.6

究竟发生了什么？如果我不更改 example.x 以指向其他内容，它会正常工作，否则如果我更改它，则会破坏其他指针。

Answer 1

TL;博士:三种不同类型的未定义行为:生命周期问题、访问 union 的非事件成员(没有非标准扩展)和通过 example.ex 的成员取消引用无效的指针值。 (对声明的 union 所代表的误解)。
看起来您可以使用普通引用。完整的解决方案在最后描述。
更深入的分析
这实际上是一个非常有趣的问题，因为这里发生了很多事情!三种不同类型的未定义行为。让我们一点一点地讨论这些。
第一 ，就像评论中提到的那样，您正在分配参数 values 的地址至 x , y和 z (成员地址)。参数values有一个自动存储持续时间，这意味着它会在 ConfigCustomDataTypeExample 的构造函数结束时被破坏。 .

struct ConfigCustomDataTypeExample {
public:
    ConfigCustomDataTypeExample() = default;
    ConfigCustomDataTypeExample(CustomDataTypeExample values) {
        x = &values.x;
        y = &values.y;
        z = &values.z;
    } // Pass this line x, y and z store invalid pointer values
      // (addresses to now destructed members of values).
      // Any indirection through these pointers is undefined behavior.
...

使用您的程序，您仍然可以读取 y 的值。和 z .这是未定义行为的本质:有时您可能会得到合理的结果，但没有任何保证。例如，当我尝试运行您的程序时， y 得到了截然不同的结果。和 z .这是第一个清晰的UB。接下来让我们检查 union 声明，以了解它真正代表什么。
类是由一系列成员组成的类型。 Union 是一种特殊类型的类，一次最多可以保存一个非静态数据成员。 union 的当前持有对象称为事件成员。这意味着 union 仅与其最大的数据成员一样大，如果需要关注内存使用情况，这很有用。

union {
  struct {
      CustomDataTypeExample* ex;
  };
  struct {
      float* x;
      float* y;
      float* z;
  };
};

对于这个 union ，成员是两个匿名结构(请注意，C++ 标准禁止匿名结构)。 union 的大小由最大的结构体决定，即 float*结构。对于 64 位系统，指针类型的大小通常为 8 个字节，因此对于 64 位系统，此 union 的大小为 24 个字节。
关于 union 的使用，您显然不是为了减少内存消耗而使用 union 。相反，您正在尝试做一些称为类型双关的事情。类型双关是当您尝试将一种类型的二进制表示解释为另一种类型时。根据 C++ 标准类型双关语是未定义行为( 第二 )，尽管许多编译器提供了允许这样做的非标准扩展。让我们分析您的 main根据标准规则编程:

ConfigCustomDataTypeExample example({1.2f, 3.4f, 5.6f});
// The anonymous struct holding 3 float* is now the active member.
// Though, all of the pointers are invalid, as already mentioned.

float value = 565;

example.x = &value;
// example.x is now a valid ptr value
 
std::cout 
    << example.ex->x << ", "  // UB: Accessing a non-active member
    << example.ex->y << ", "  // UB: non-active and invalid ptr (more on that later)
    << example.ex->z << "\n"; // UB: same as above

std::cout 
    << *example.x << ", "     // This is ok (active member and valid ptr)
    << *example.y << ", "     // UB: indirection to an invalid ptr
    << *example.z << "\n";    // UB: same as above

再一次，未定义的行为足以打印 565取消引用时 example.ex->x .这是因为 float* x和 example.ex->x union 的二进制表示中的重叠，尽管这仍然是未定义的行为。
让我们先通过更改 ConfigCustomDataTypeExample 来快速解决生命周期问题将引用作为参数: ConfigCustomDataTypeExample(CustomDataTypeExample& values)并声明一个 CustomDataTypeExample主要变量。 我也在用 gcc 编译，其中带有 union 的类型双关定义明确(非标准扩展):

CustomDataTypeExample data{1.0f, 2.0f, 3.0f};
ConfigCustomDataTypeExample example(data);
    
float value = 565;
example.x = &value;

std::cout 
    << example.ex->x << ", "  // This is now ok (using gcc's non-standard extension)
    << example.ex->y << ", "  // Something seems odd
    << example.ex->z << "\n"; // with these two lines
    
std::cout 
    << *example.x << ", "     // Now well defined
    << *example.y << ", "     // same
    << *example.z << "\n";    // same

这里什么也没有。我的一次运行的输出是:

565, 1961.14, 4.59163e-41
565, 2, 3

好的，至少现在 x , y和 z值是有效的，但在取消引用 example.ex 的部分时我们仍然得到垃圾值.是什么赋予了？让我们回到我们 union 的声明并思考它如何转换为它的二进制表示。这是一个粗略的图表:

[float* x, float* y, float* z]

所以我们 union 的内存布局是三个浮点指针， 每个指向单个浮点值 (相当于一个存储三个浮点指针的数组，例如 float* arr[3] )。 然而，与 example.ex我们试图解释 float* x作为 3 个浮点数组 .这是因为 CustomDataTypeExample的内存布局相当于一个包含 3 个浮点值的数组，尝试引用其成员相当于数组索引。
我认为 gcc 的扩展基于它对 example->ex 的解释在 C90 标准第 6.5.2.2 节脚注 82 上:

If the member used to access the contents of a union object is not the same as the member last used tostore a value in the object, the appropriate part of the object representation of the value is reinterpretedas an object representation in the newtype as described in 6.2.6 (a process sometimes called "type punning"). This might be a trap representation.

我们还可以通过查看编译器如何将这三行转换为汇编来验证这一点:

example.x = &value;

std::cout 
    << example.ex->x << ", " 
    << example.ex->y << ", " 
    << example.ex->z << "\n";

使用 godbolt我们得到以下信息(我只选取了相关的部分):

// Copies the value of rax to the memory pointed by QWORD PTR [rbp-48]
mov     QWORD PTR [rbp-48], rax  // example.x = &value;

// Copy a 32-bit value from memory address rax to eax.
// (eax register is used here to pass the value to std::cout)
// No surprises yet, as this address has a well defined floating point value (526).
mov     eax, DWORD PTR [rax]     // example.ex->x

// Not good, tries to copy a floating point value from memory address 
// [rax + 4 bytes]. Equivalent to *(&value + 1). This is gonna get 
// whatever random junk is in that part of memory.
mov     eax, DWORD PTR [rax+4]   // example.ex->y

我们可以很清楚地看到编译器如何尝试解释 example.ex 指向的地址。 作为内存中包含 3 个浮点值的区域，即使它只包含一个 .因此，第一次读取没问题，但第二次和第三次取消引用就出错了。
这段代码产生了极其相似的程序集，这并不奇怪，因为行为是等效的:

float* value_ptr = &value;

std::cout
    << *value_ptr << ", "    // equivalent to example.ex->x, OK
    << value_ptr[1] << ", "  // equivalent to example.ex->y, plain UB
    << value_ptr[2] << '\n'; // equivalent to example.ex->z, plain UB

这是未定义行为的情况与第一种情况非常相似。该程序正在通过无效的指针值( 第三个 )执行间接访问。
当您执行 main 时，这三个未定义的行为结合在一起导致出现奇怪的值。 .现在解决方案。
解决方案
首先让我们排除一些小吹毛求疵。 CustomDataTypeExample显然是一个只将数据包含在其中的聚合，因此不需要为它显式声明特殊的成员函数(在这种情况下是构造函数)。特殊成员函数是隐式声明的(并且是微不足道的):

struct CustomDataTypeExample {
    float x;
    float y;
    float z;
};

// Construct an instance of CustomDataTypeExample by aggregate initializing.
// This was also utilized earlier.
CustomDataTypeExample data{1.0f, 2.0f, 3.0f};

解决方案是什么，看起来您正试图为一个简单的问题提出一个额外的抽象层。简单的引用应该可以解决问题。没有理由进行复杂的 union 设置，正如您可能已经注意到的那样，它非常容易出错。在 C++ 中， union 应该只真正用于减少系统上的内存消耗，因为内存是一种稀缺资源。
因此，我只想摆脱 ConfigCustomDataTypeExample并像这样使用引用:

CustomDataTypeExample data{1.0f, 2.0f, 3.0f};
CustomDataTypeExample& data_ref = data;

// Modifies the contents of the existing data
data_ref.x = 565;

std::cout 
    << data_ref.x << ", " 
    << data_ref.y << ", " 
    << data_ref.z << '\n';

当您使用具有自动存储持续时间的变量时，引用是必经之路。与指针相比，引用生命周期问题更难创建，整体解决方案通常更简单。