在阅读另一个关于别名的问题 (What is the strict aliasing rule?) 及其最佳答案时，我意识到我仍然不完全满意，尽管我认为我已经完全理解了。

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

所以我想了解如何在这个领域进行一些开发，以积极的方式转换指针，但使用一个简单的保守规则来确保我不会引入 UB。我在这里有这样一条规则的建议。

(更新:当然，我们可以避免所有类型的双关语。但这不是很有教育意义。除非当然，除了 union 异常。)

更新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
   }
}

最佳答案

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

If a program attempts to access the stored value of an object through a glvalue of other than one of the following types the behavior is undefined:

• the dynamic type of the object,
• a cv-qualified version of the dynamic type of the object,
• a type similar (as defined in 4.4) to the dynamic type of the object,
• a type that is the signed or unsigned type corresponding to the dynamic type of the object,
• a type that is the signed or unsigned type corresponding to a cv-qualified version of the dynamic type of the object,
• an aggregate or union type that includes one of the aforementioned types among its elements or nonstatic data members (including, recursively, an element or non-static data member of a subaggregate or contained union),
• a type that is a (possibly cv-qualified) base class type of the dynamic type of the object,
• a char or unsigned char type.

根据 4.4，“相似类型”涉及修改多级指针的 cv 限定。

因此，如果您曾经通过指向一种类型的指针(或其他访问器)写入某个区域，则您不能通过指向不同类型的指针访问它(除非被 3.10/10 批准)，即使您忘记了旧指针。

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

关于c++ - 避免违反严格别名规则的最简单经验法则？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31429214/