用相同类型的新对象覆盖对象并使用 this 闭包

Question

在以下代码中，一个对象被相同类型的新对象覆盖，其中 lambda 表达式创建一个使用旧对象的 this 的闭包。旧地址 (this) 保持不变，新对象具有相同的布局，所以这应该没问题，而不是 UB。但是对于不平凡的对象或其他情况呢？

struct A {
    void g(A& o, int v) {
        o = A{.x = v, .f = [this]{
            std::cout << "f" << this->x << '\n';
        }};
    }
    int x{0};
    std::function<void()> f;
    ~A() {
        std::cout << "dtor" << x << '\n';
    }
};

void test() {
    A a;
    a.g(a, 2);
    a.f();
}

Answer 1

您实际上并没有替换任何对象。您只是将另一个对象分配给当前对象。 o = 只是调用隐式复制赋值运算符，该运算符将从使用 A{...} 的赋值表达式构造的临时 A 中复制赋值各个成员。。

lambda 将从 g 中的 this 捕获 this，而不是从临时对象。

std::function 将始终保留引用调用 g 的原始对象的 lambda 副本，并且由于那是其父对象，因此它的寿命不能超过它。

所以这里没有问题。唯一的例外是在销毁 A 对象期间调用 f，在这种情况下，可能会禁止使用捕获的指针。

Answer 2

这是一个稍微修改过的代码，带有一个极端情况。我在函数中创建一个临时对象，并对其调用 g 并传递给它一个更永久的对象。临时对象消失了，长寿命对象现在有一个闭包来引用寿命结束后的对象。调用f is UB：

#include <iostream>
#include <functional>

struct A {
    void g(A& o, int v) {
        o = A{ .x = v, .f = [this] {
            std::cout << "f" << this->x << ' ' << this << '\n';
        } };
    }
    int x{ 0 };
    std::function<void()> f;
    ~A() {
        std::cout << "dtor" << x <<  ' ' << this << '\n';
    }
};

void test(A& a) {
    A b{ 2 };
    b.g(a, 3);
}

int main() {
    A a{ 1 };
    std::cout << a.x << '\n';
    test(a);
    std::cout << a.x << '\n';
    a.f();   // UB because a.f uses an object after its end of life
}

输出为：

1
dtor3 0135F9C0
dtor2 0135FA30
3
f341072 0135FA30
dtor3 0135FAA8

证明af()的调用在被销毁后尝试使用地址0135FA30处的对象（在该特定运行中） 。