const 成员和赋值运算符。如何避免未定义的行为？

Question

我回答了有关std::vector of objects and const- Correctness，并收到有关未定义行为的评论。我不同意，因此我有一个问题。

考虑带有 const 成员的类：

class A { 
public: 
    const int c; // must not be modified! 
    A(int c) : c(c) {} 
    A(const A& copy) : c(copy.c) { }     
    // No assignment operator
}; 

我想要一个赋值运算符，但我不想使用 const_cast 就像答案之一的以下代码所示：

A& operator=(const A& assign) 
{ 
    *const_cast<int*> (&c)= assign.c;  // very very bad, IMHO, it is undefined behavior
    return *this; 
} 

我的解决方案是

// Custom-defined assignment operator
A& operator=(const A& right)  
{  
    if (this == &right) return *this;  

    // manually call the destructor of the old left-side object
    // (`this`) in the assignment operation to clean it up
    this->~A(); 
    // use "placement new" syntax to copy-construct a new `A` 
    // object from `right` into left (at address `this`)
    new (this) A(right); 
    return *this;  
}  

我是否有未定义的行为 (UB)？

没有 UB 的解决方案是什么？

Answer 1

您的代码会导致未定义的行为。

不仅仅是“如果 A 用作基类以及这个、那个或另一个则未定义”。实际上始终是未定义的。 return *this 已经是 UB，因为 this 不能保证引用新对象。

具体来说，考虑 3.8/7：

如果，在对象的生命周期之后
已结束且在存储之前
占用的对象被重复使用或
释放后，会创建一个新对象
的存储位置
原来占用的对象，一个指针
指向原始对象，a
参考文献 提到了
原始对象，或名称
原始对象将自动
引用新对象，一旦
新对象的生命周期有
启动后，可用于操纵
新对象，如果：

...

——原始对象的类型是
不是 const 限定的，并且，如果一个类
类型，不包含任何非静态
其类型为的数据成员
const 限定或引用类型，

现在，“在对象的生命周期结束后，在重用或释放该对象占用的存储空间之前，在原始对象占用的存储位置创建一个新对象”正是这样你正在做。

您的对象属于类类型，并且它确实包含类型为 const 限定的非静态数据成员。因此，在赋值运算符运行后，引用旧对象的指针、引用和名称不能保证引用新对象并可用于操作它。

作为可能出错的具体示例，请考虑：

A x(1);
B y(2);
std::cout << x.c << "\n";
x = y;
std::cout << x.c << "\n";

期望此输出吗？

1
2

错误的！您可能会得到该输出，但 const 成员是 3.8/7 中所述规则的例外的原因是编译器可以将 xc 视为它声称的 const 对象。换句话说，编译器可以将此代码视为：

A x(1);
B y(2);
int tmp = x.c
std::cout << tmp << "\n";
x = y;
std::cout << tmp << "\n";

因为（非正式地）const 对象不会更改其值。当优化涉及 const 对象的代码时，这种保证的潜在价值应该是显而易见的。为了有任何方法可以在不调用 UB 的情况下修改 xc ，，必须删除此保证。所以，只要标准编写者没有错误地完成了他们的工作，就没有办法做你想做的事。

[*] 事实上，我对使用 this 作为放置新的参数存有疑问 - 也许您应该首先将其复制到 void* 并使用它。但我并不关心这是否是 UB，因为它不会保存整个函数。

Answer 2

第一：当您将数据成员设为const时，您就是在告诉编译器和全世界该数据成员永远不会改变。当然，那么你不能给它赋值，而且你当然一定不能欺骗编译器接受这样做的代码，无论这个伎俩多么聪明。
您可以使用 const 数据成员或为所有数据成员分配一个赋值运算符。 两者不可兼得。

至于您对问题的“解决方案”：
我想在为该对象调用的成员函数中调用该对象的析构函数会立即调用UB。 对未初始化的原始数据调用构造函数，以从成员函数中创建一个对象，该成员函数是为一个对象调用的，该对象位于现在对原始数据调用构造函数的位置...也非常对我来说听起来很像UB。 （天哪，光是把这个拼出来就让我的脚趾甲卷曲了。）而且，不，我没有这方面标准的章节和诗句。我讨厌阅读标准。我想我无法忍受它的仪表。

然而，抛开技术细节不谈，我承认您可能会在几乎所有平台上使用您的“解决方案”只要代码保持与示例中一样简单。尽管如此，这并不能使它成为一个好的解决方案。事实上，我认为这甚至不是一个可接受的解决方案，因为 IME 代码永远不会那么简单。多年来，它会被扩展、改变、变异和扭曲，然后它会悄无声息地失败，并且需要令人麻木的 36 小时轮班调试才能找到问题。我不知道你是怎么想的，但每当我发现一段像这样的代码可以带来 36 小时的调试乐趣时，我就想掐死那个对我做出这种事的可怜的傻瓜。

Herb Sutter，在他的GotW #23< /a>，逐条剖析这个想法，最后得出结论：它“充满陷阱，它经常是错误的，并且它使派生类的作者的生活变成了地狱...永远不要使用通过复制构造来实现复制分配的技巧使用显式析构函数，然后放置 new，尽管这个技巧每三个月就会出现在新闻组中”（强调我的）。

Answer 3

如果 A 有 const 成员，你怎么可能分配给它呢？你正试图完成一些根本上不可能的事情。您的解决方案与原始解决方案相比没有新的行为，这不一定是 UB，但您的解决方案绝对是。

简单的事实是，您正在更改 const 成员。您要么需要取消您的成员，要么放弃赋值运算符。你的问题没有解决办法——这完全是矛盾的。

编辑以获得更清晰的信息：

Const 强制转换并不总是引入未定义的行为。然而，你肯定做到了。除此之外，在放入它之前不调用所有析构函数是未定义的 - 而且您甚至没有调用正确的析构函数，除非您确定 T 是一个 POD 类。此外，还有一些与各种形式的继承相关的未定义行为。

您确实会调用未定义的行为，并且可以通过不尝试分配给 const 对象来避免这种情况。

Answer 4

首先，您使用“placement new”作为实现赋值运算符 operator=() 的手段（我可能会说非常巧妙）的整个动机是：受到这个问题的煽动（std::vector of objects and const- Correctness ），现已作废。从 C++11 开始，该问题的代码现在没有错误。请参阅我的回答。

其次， C++11 的 emplace() 函数现在的功能与您使用 placement new 的功能几乎完全相同，只是它们都是现在几乎由编译器本身保证按照 C++ 标准定义良好的行为。

第三，当接受的答案指出：

因为 this 不能保证引用新对象

我想知道这是否是因为 this 变量中包含的值可能会被放置新的复制构造操作更改，不是因为使用该类实例的任何内容都可能保留它的缓存值以及旧实例数据，而不是从内存中读取对象实例的新值。如果是前者，在我看来，您可以通过使用 this 指针的临时副本来确保 this 在赋值运算符函数中是正确的，如下所示：

// Custom-defined assignment operator
A& operator=(const A& right)  
{  
    if (this == &right) return *this;  

    // manually call the destructor of the old left-side object
    // (`this`) in the assignment operation to clean it up
    this->~A(); 

    // Now back up `this` in case it gets corrupted inside this function call
    // only during the placement new copy-construction operation which 
    // overwrites this objct:
    void * thisBak = this;

    // use "placement new" syntax to copy-construct a new `A` 
    // object from `right` into left (at address `this`)
    new (this) A(right); 

    // Note: we cannot write to or re-assign `this`. 
    // See here: https://stackoverflow.com/a/18227566/4561887

    // Return using our backup copy of `this` now
    return *thisBak;  
}  

但是，如果与被缓存的对象有关，并且每次使用时都不会重新读取它，我想知道易失性是否可以解决这个问题！即：使用volatile const int c;作为类成员，而不是const int c;。

第四，在我的回答的其余部分中，我重点关注应用于类成员的易失性的使用，看看这是否可以解决这两个潜在的未定义行为情况中的第二个：< /strong>

1. 您自己的解决方案中潜在的 UB：

    // 自定义赋值运算符
    A&运算符=(const A&右)  
    {  
        if (this == &right) return *this;  
   
        // 手动调用旧左侧对象的析构函数
        // (`this`) 在赋值操作中清理它
        这->~A(); 
        // 使用“placement new”语法复制构造一个新的 `A` 
        // 对象从“右”到左（在地址“this”处）
        新（这个）A（右）； 
        返回*这个；  
    }  
   

2. 您提到的潜在 UB 可能存在于其他解决方案中。

    // （你的话，不是我的话）：“非常非常糟糕，恕我直言，这是 
    // 未定义的行为”
    *const_cast; (&c)= 分配.c;
   

虽然我认为也许添加易失性可能会解决上面的两种情况，但我在这个答案的其余部分的重点是上面的第二种情况。

tldr;

在我看来，如果您添加 volatile 并进行类成员变量volatile const int c;，而不仅仅是const int c;。我不能说这是一个好主意，但我认为抛弃 const 并写入 c 然后就成为定义明确的行为并且完全有效。否则，该行为未定义，只是因为 c 的读取可能会被缓存和/或优化，因为它只是 const，而不是<代码>易失性。

请阅读下面的内容以获取更多详细信息和理由，包括查看一些示例和一些汇编。

const 成员和赋值运算符。如何避免未定义的行为？

写入 const 成员只是未定义的行为...

...因为编译器可能会优化对变量的进一步读取，因为它是 const 。换句话说，即使您已经正确更新了内存中给定地址处包含的值，编译器也可能会告诉代码只返回寄存器中最后一个保存它第一次读取的值的内容，而不是返回到内存地址并在每次从该变量读取时实际检查新值。

所以这：

// class member variable:
const int c;    

// anywhere
*const_cast<int*>(&c) = assign.c;

可能是未定义的行为。它可能在某些情况下起作用，但在其他情况下不起作用，在某些编译器上起作用，但在其他编译器上不起作用，或者在某些版本的编译器上起作用，但在其他编译器上不起作用。我们不能依赖它来实现可预测的行为，因为该语言没有指定每次我们将变量设置为 const 然后写入和读取时会发生什么。

例如，这个程序（请参见此处：https://godbolt.org/z/EfPPba）：

#include <cstdio>
int main() {
  const int i = 5;
  *(int*)(&i) = 8;
  printf("%i\n", i);
  return 0;
}

打印 5 （尽管我们希望它打印 8）并在 main 中生成此程序集。 （请注意，我不是组装专家）。我已经标记了 printf 行。您可以看到，即使 8 写入该位置 (mov DWORD PTR [rax], 8)，printf 行也不会读取出这个新值。他们读出了之前存储的 5，因为他们不希望它发生变化，尽管它确实发生了变化。该行为未定义，因此在这种情况下省略读取。

push    rbp
mov     rbp, rsp
sub     rsp, 16
mov     DWORD PTR [rbp-4], 5
lea     rax, [rbp-4]
mov     DWORD PTR [rax], 8

// printf lines
mov     esi, 5
mov     edi, OFFSET FLAT:.LC0
mov     eax, 0
call    printf

mov     eax, 0
leave
ret

然而，写入 易失性 const 变量不是未定义的行为......

因为易失性告诉编译器它最好读取以下内容：每次读取该变量时的实际内存位置，因为它可能随时更改！

你可能会想：“这还有道理吗？” （有一个 易失性 const 变量。我的意思是：“什么可能会改变 const 变量，使我们需要将其标记为 易失性！？）答案是：“嗯，是的！它确实有道理！”在微控制器和其他低级内存映射嵌入式设备上，一些寄存器（可能随时由底层硬件更改）是只读的。为了将它们标记为只读，仅在 C 或 C++ 中，我们将它们设置为 const，但为了确保编译器知道，每次我们读取变量时，它都会更好地实际读取其地址位置的内存， >我们不是依赖于保留先前缓存的值的优化，而是将它们标记为易失性，因此，将地址0xF000标记为只读8。 -bit 寄存器名为 REG1，我们会在头文件中的某个位置定义它：

// define a read-only 8-bit register
#define REG1 (*(volatile const uint8_t*)(0xF000))

现在，我们可以随心所欲地读取它，并且每次我们要求代码读取变量，它会的。这是明确定义的行为。现在，我们可以执行类似的操作，并且此代码不会得到优化，因为编译器知道该寄存器值实际上可能会更改。在任何给定时间，因为它是易失性：

while (REG1 == 0x12)
{
    // busy wait until REG1 gets changed to a new value
}

并且，要将REG2标记为8位读/写寄存器，当然，我们只需删除常量。然而，在这两种情况下，都需要 volatile ，因为这些值可能会在任何给定时间由硬件更改，因此编译器最好不要对这些变量做出任何假设或尝试缓存它们的值并依赖于缓存读数。

// define a read/write 8-bit register
#define REG2 (*(volatile uint8_t*)(0xF001))

因此，以下不是未定义的行为！据我所知，这是非常明确定义的行为：

// class member variable:
volatile const int c;    

// anywhere
*const_cast<int*>(&c) = assign.c;

即使变量是 const，我们也可以抛弃 const 并写入它，编译器会尊重它并实际写入它。 而且，现在变量也标记为易失性，编译器将每次读取它，并且也尊重这一点，与阅读上面的 REG1 或 REG2 相同。

因此，现在我们添加了 易失性（请参见此处：https:// godbolt.org/z/6K8dcG)：

#include <cstdio>
int main() {
  volatile const int i = 5;
  *(int*)(&i) = 8;
  printf("%i\n", i);
  return 0;
}

打印 8，现在是正确的，并在 main 中生成此程序集。我再次标记了 printf 行。请注意我标记的新的和不同的行！这些是对程序集输出的唯一更改！其他每一行都完全相同。下面标记的新行将输出并实际读取变量的新值并将其存储到寄存器eax中。接下来，在准备打印时，它不会像之前那样将硬编码的 5 移动到寄存器 esi 中，而是移动寄存器 eax 的内容code>，刚刚被读取，现在包含一个 8，进入寄存器 esi。解决了！添加易失性修复了它！

push    rbp
mov     rbp, rsp
sub     rsp, 16
mov     DWORD PTR [rbp-4], 5
lea     rax, [rbp-4]
mov     DWORD PTR [rax], 8

// printf lines
mov     eax, DWORD PTR [rbp-4]  // NEW!
mov     esi, eax                // DIFFERENT! Was `mov     esi, 5`
mov     edi, OFFSET FLAT:.LC0
mov     eax, 0
call    printf

mov     eax, 0
leave
ret

这是一个更大的演示（在线运行：https://onlinegdb.com/HyU6fyCNv）。您可以看到，我们可以通过将变量转换为非常量引用或非常量指针来写入变量。

在所有情况下（转换为非常量引用或非常量指针以修改 const 值），我们可以使用 C++ 样式转换或 C 样式转换。

在上面的简单示例中，我验证了在所有四种情况下（甚至使用 C 样式强制转换来强制转换为引用：(int&)(i) = 8;，奇怪的是，因为 C没有引用:)) 程序集输出是相同的。

#include <stdio.h>

int main()
{
    printf("Hello World\n");

    // This does NOT work!
    const int i1 = 5;
    printf("%d\n", i1);
    *const_cast<int*>(&i1) = 6;
    printf("%d\n\n", i1); // output is 5, when we want it to be 6!
    
    // BUT, if you make the `const` variable also `volatile`, then it *does* work! (just like we do
    // for writing to microcontroller registers--making them `volatile` too). The compiler is making
    // assumptions about that memory address when we make it just `const`, but once you make it
    // `volatile const`, those assumptions go away and it has to actually read that memory address
    // each time you ask it for the value of `i`, since `volatile` tells it that the value at that
    // address could change at any time, thereby making this work.

    // Reference casting: WORKS! (since the `const` variable is now `volatile` too)

    volatile const int i2 = 5;
    printf("%d\n", i2);
    const_cast<int&>(i2) = 7;
    // So, the output of this is 7:
    printf("%d\n\n", i2);
    
    // C-style reference cast (oddly enough, since C doesn't have references :))
    
    volatile const int i3 = 5;
    printf("%d\n", i3);
    (int&)(i3) = 8;
    printf("%d\n\n", i3);
    

    // It works just fine with pointer casting too instead of reference casting, ex:
    
    volatile const int i4 = 5;
    printf("%d\n", i4);
    *(const_cast<int*>(&i4)) = 9;
    printf("%d\n\n", i4);

    // or C-style:
    
    volatile const int i5 = 5;
    printf("%d\n", i5);
    *(int*)(&i5) = 10;
    printf("%d\n\n", i5);


    return 0;
}

示例输出：

Hello World
5
5

5
7

5
8

5
9

5
10

注意：

1. 我还注意到，在修改 const 类成员时，即使它们不是 易失性，上述方法也有效。请参阅我的“std_Optional_copy_test”程序！例如：https://onlinegdb.com/HkyNyTt4D。然而，这可能是未定义的行为。为了使其定义良好，请将成员变量设置为volatile const，而不仅仅是const。
2. 您不必从 易失性 const int 转换为 易失性 int 的原因（即：为什么只转换为 int 引用或 int 指针）工作得很好，因为 volatile 影响变量的读取，而不是变量的写入。因此，只要我们通过易失性变量方式读取变量（我们这样做了），就保证我们的读取不会被优化。这就是给我们明确定义的行为的原因。即使变量不是易失性，写入始终有效。

参考文献：

1. [我自己的答案] “放置”有什么用途新的”？
2. x86 组装指南
3. 更改对象的“this”指针以指向不同的对象
4. 编译器资源管理器输出（含汇编），来自 godbolt.org：
   1. 此处：https://godbolt.org/z/EfPPba
   2. 这里：https://godbolt.org/z/6K8dcG
5. [我的答案] STM32 微控制器上的寄存器级 GPIO 访问：像STM8一样编程STM32（寄存器级GPIO）

Answer 5

如果你确实想要一个不可变（但可分配）的成员，那么在没有 UB 的情况下，你可以这样布置：

#include <iostream>

class ConstC
{
    int c;
protected:
    ConstC(int n): c(n) {}
    int get() const { return c; }
};

class A: private ConstC
{
public:
    A(int n): ConstC(n) {}
    friend std::ostream& operator<< (std::ostream& os, const A& a)
    {
        return os << a.get();
    }
};

int main()
{
    A first(10);
    A second(20);
    std::cout << first << ' ' << second << '\n';
    first = second;
    std::cout << first << ' ' << second << '\n';
}

Answer 6

根据较新的 C++ 标准草案版本 N4861，它似乎不再是未定义的行为 （链接）：

如果在一个对象的生命周期结束之后并且在该对象的存储之前
占用被重用或释放，在存储位置创建一个新对象
占用的原始对象、指向原始对象的指针、引用原始对象的引用或原始对象的名称将
自动引用新对象，并且一旦新对象的生命周期开始，如果原始对象可以透明地由新对象替换（见下文），则可以用于操作新对象。
对象 o1 可以透明地被对象 o2 替换，如果：

• o2 占用的存储空间恰好覆盖 o1 占用的存储空间，并且
• o1 和 o2 属于同一类型（忽略顶级 cv 限定符），并且
• o1 不是一个完整的 const 对象，并且
• o1 和 o2 都不是潜在重叠的子对象 ([intro.object])，并且
• 要么 o1 和 o2 都是完整的对象，要么 o1 和 o2 分别是对象 p1 和 p2 的直接子对象，并且 p1 可以透明地被 p2 替换。

在这里你只能找到关于 const 的“o1 不是一个完整的 const 对象”，在本例中确实如此。但当然，您还必须确保不违反所有其他条件。

Answer 7

在没有其他（非 const ）成员的情况下，无论是否存在未定义的行为，这都没有任何意义。

A& operator=(const A& assign) 
{ 
    *const_cast<int*> (&c)= assign.c;  // very very bad, IMHO, it is UB
    return *this; 
}

AFAIK，这不是这里发生的未定义行为，因为 c 不是 static const 实例，或者您无法调用复制赋值运算符。但是，const_cast 应该敲响警钟并告诉您出现了问题。 const_cast 主要设计用于解决非 const 正确的 API，但这里的情况似乎并非如此。

另外，在以下代码片段中：

A& operator=(const A& right)  
{  
    if (this == &right) return *this;  
    this->~A() 
    new (this) A(right); 
    return *this;  
}

您有两个主要风险，其中第一个风险已经指出。

1. 如果同时存在 A 派生类的实例和虚拟析构函数，这将导致仅部分重建原始实例。
2. 如果 new(this) A(right); 中的构造函数调用抛出异常，则您的对象将被销毁两次。在这种特殊情况下，这不会成为问题，但如果您碰巧进行了重大清理，您会后悔的。

编辑：如果您的类具有此 const 成员，则该成员不被视为对象中的“状态”（即，它是用于跟踪实例的某种 ID，并且不属于operator== 等中的比较），那么以下内容可能有意义：

A& operator=(const A& assign) 
{ 
    // Copy all but `const` member `c`.
    // ...

    return *this;
}

Answer 8

阅读此链接：

http://www.informit。 com/guides/content.aspx?g=cplusplus&seqNum=368

特别是...

这个技巧据称可以阻止代码
重复。然而，它有一些
严重缺陷。为了工作，C
析构函数必须分配 NULLify every
它已删除的指针，因为
随后的复制构造函数调用
可能会再次删除相同的指针
当它为 char 重新分配新值时
数组。