避免违反严格混叠规则的最简单的经验法则？

Question

在阅读有关别名的另一个问题 (What is the strict aliasing rule?) 及其最佳答案时，我意识到我仍然不完全满意，即使我认为我在那里理解了所有内容。

（这个问题现在被标记为 C 和 C++。如果您的答案只涉及其中之一，请说明是哪一个。）

所以我想了解如何在这方面进行一些开发，以激进的方式投射指针，但有一个简单的保守规则，以确保我不会引入 UB。我有一个关于这样一条规则的建议。

(更新：当然，我们可以避免所有类型的双关语。但这不是很有教育意义。当然，除了@987654323 之外，确实存在零个明确定义的例外@异常。)

更新 2：我现在明白为什么这个问题中提出的方法不正确。但是，了解是否存在简单、安全的替代方案仍然很有趣。截至目前，至少有一个答案提出了这样的解决方案。

这是原始示例：

int main()
{
   // Get a 32-bit buffer from the system
   uint32_t* buff = malloc(sizeof(Msg));

   // Alias that buffer through message
   Msg* msg = (Msg*)(buff);

   // Send a bunch of messages    
   for (int i =0; i < 10; ++i)
   {
      msg->a = i;
      msg->b = i+1;
      SendWord(buff[0] );
      SendWord(buff[1] );   
   }
}

重要的一行是：

Msg* msg = (Msg*)(buff);

这意味着现在有两个（不同类型的）指针指向相同的数据。我的理解是，任何通过其中一个进行写入的尝试都会使另一个指针基本上无效。 （“无效”是指我们可以安全地忽略它，但通过无效指针读取/写入是 UB。）

Msg* msg = (Msg*)(buff);
msg->a = 5;           // writing to one of the two pointers
SendWord(buff[0] );   // renders the other, buffer, invalid

因此，我建议的规则是，一旦您创建了第二个指针（即创建 msg），您应该立即并永久地“淘汰”另一个指针。

有什么比将指针设置为 NULL 更好的方法来引退指针：

Msg* msg = (Msg*)(buff);
buff = NULL; // 'retire' buff. now just one pointer
msg->a = 5;

现在，分配给msg->a 的最后一行不能使任何其他指针无效，因为当然没有。

接下来，当然，我们得想办法打电话给SendWord(buff[1] );。这不能立即完成，因为buff 已停用并且为 NULL。我现在的建议是再次投退。

Msg* msg = (Msg*)(buff);
buff = NULL; // 'retire' buff. now just one pointer
msg->a = 5;

buff = (uint32_t*)(msg);   // cast back again
msg = NULL;                // ... and now retire msg

SendWord(buff[1] );

总而言之，每次你在两个“不兼容”类型之间转换一个指针（我不确定如何定义“不兼容”？），那么你应该立即“淘汰”旧指针。如果这有助于您执行规则，请将其显式设置为 NULL。

这样够保守吗？

也许这太保守了，还有其他问题，但我首先想知道这是否足够保守，以避免通过违反严格的别名来引入 UB。

最后，回顾一下原始代码，修改为使用这条规则：

int main()
{
   // Get a 32-bit buffer from the system
   uint32_t* buff = malloc(sizeof(Msg));

   // Send a bunch of messages    
   for (int i =0; i < 10; ++i)
   {  // here, buff is 'valid'

      Msg* msg = (Msg*)(buff);
      buff = NULL;
      // here, only msg is 'valid', as buff has been retired
      msg->a = i;
      msg->b = i+1;
      buff = (uint32_t*) msg;  // switch back to buff being 'valid'
      msg = NULL;              // ... by retiring msg
      SendWord(buff[0] );
      SendWord(buff[1] );
      // now, buff is valid again and we can loop around again
   }
}

Answer 1

C++ 答案：那行不通。 C++ 严格的别名规则明确列举了哪些类型可以用来访问一个对象。如果你使用不同的类型，你会得到 UB，即使你已经“淘汰”了不同类型的所有访问方法。根据 C++14 (n4140) 3.10/10，允许的类型是：

如果一个程序试图通过 Glvalue 访问一个对象的存储值，而不是其中一个 以下类型的行为未定义：

• 对象的动态类型，
• 对象动态类型的 cv 限定版本，
• 与对象的动态类型类似（如 4.4 中定义）的类型，
• 对应于对象动态类型的有符号或无符号类型，
• 一种有符号或无符号类型，对应于动态类型的 cv 限定版本 对象，
• 在其元素中包含上述类型之一或非静态的聚合或联合类型 数据成员（递归地包括子聚合的元素或非静态数据成员） 或包含联合），
• 一种类型，它是对象动态类型的（可能是 cv 限定的）基类类型，
• char 或 unsigned char 类型。

“类似类型”，根据 4.4，与修改多级指针的 cv 限定有关。

因此，如果您曾经通过指向一种类型的指针（或其他访问器）写入区域，即使您忘记了，也无法通过指向不同类型的指针访问它（除非 3.10/10 批准）旧指针。

如果您从未通过特定类型写入区域，则来回转换指针不是问题。

Answer 2

规则是：

"除非指针是兼容的类型。你不能有两个 指向同一个内存的指针。”

这是一个更简单的无限循环示例：

1: int *some_buff = malloc(sizeof(whatever));
2: memset(some_buff,0,sizeof(whatever));
3: while (some_buff[0] == 0)
4: {
5:     whatever *manipulator = (whatever*)some_buff; 
6:     manipulate(manipulator);
7: }

这本质上是编译器将/可以处理此代码的方式：

some_buff[0] == 0 的测试可以优化出来，因为有 无法更改 some_buff[0] 的有效方法。它是 通过manipulator 访问，但manipulator 不是 兼容类型，因此根据严格的别名规则， some_buff[0] 的值不能改变。

如果你想要一个更简单的例子：

int *some_buff = malloc(sizeof(whatever));
memset(some_buff,0,sizeof(whatever));
whatever *manipulator = (whatever*)some_buff;
manipulate(manipulator);
printf("%d\n",some_buff[0]);

这段代码总是打印零是完全可以的，不管操作是什么。

Answer 3

我的理解是，任何试图通过其中之一进行写作的尝试 将使另一个指针基本上无效。

只要您不访问类型双关指针，另一个“官方”指针就可以了。然而，如果你这样做，它会导致未定义的行为，这可能只是工作，做你所说的或这个星系之外的事情，包括使另一个指针无效。编译器可以随意处理 UB。

根据标准，使buff 成为指向Msg 的有效指针的唯一方法是memcpy/memmove：

memcpy( (void*)msg, (const void*) buff, sizeof (*msg));

此外，触发 UB 的不仅是写入，还有 读取 或任何其他访问对象的方式：

如果程序尝试访问对象的存储值 不是以下类型之一的左值行为是 未定义：

一些编译器还允许“暂停”该规则，例如 GCC、clang 和 ICC（可能还有 MSVC），但这不能被视为可移植或标准行为。 进一步的技术，以及它们的代码生成分析，被彻底分析here。

你真的需要打破严格的别名规则吗？

大多数时候，不，你不需要那个。有ways and ways 来克服涉及完全合法解决方案的问题。 在上述情况下，只需在struct 中存储一个普通指针，并以确定的格式发送每个成员。

Answer 4

您的建议根本没有帮助，因为在使用指针变量后分配什么值并不重要。您确实通过不兼容类型的指针访问相同的内存位置。

对于 C（不是对于 C++），除了避免类型双关语之外，至少有一件安全的事情可以做：您可以安全地将指针转换为结构，因为一种结构类型只是添加字段到对方的尽头。这甚至在较长的结构只包含较短的结构作为其第一个成员时也有效：指向结构的指针指向其第一个成员。所以例如这些在 C 中是安全的：

typedef struct
{
    int id;
    const char *name;
} base_t;

typedef struct
{
    base_t base;
    long foo;
} derived_t;

derived_t *d = malloc(sizeof derived_t);
base_t *b = (base_t *)d;
int *i = (int *)d;