std::launder

来自cppreference.com
< cpp‎ | utility
 
 
工具库
语言支持
类型支持(基本类型、RTTI)
库功能特性测试宏 (C++20)
动态内存管理
程序工具
协程支持 (C++20)
变参数函数
调试支持
(C++26)
三路比较
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
通用工具
日期和时间
函数对象
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中弃用)
整数比较函数
(C++20)(C++20)(C++20)   
(C++20)
交换类型运算
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
常用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
初等字符串转换
(C++17)
(C++17)

 
动态内存管理
未初始化内存算法
受约束的未初始化内存算法
分配器
垃圾收集器支持
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)



 
 
在标头 <new> 定义
template< class T >
constexpr T* launder( T* p ) noexcept;
(C++17 起)

有关 p 的去虚化屏障。获得指向位于 p 所表示的相同内存的指针,但所引用的对象假定具有与之无关的生存期和动态类型。

正式而言,给定

  • 表示内存中一个字节的地址 A 的指针 p
  • 一个位于地址 A 的对象 x
  • x 在它的生存期
  • x 的类型与 T 相同,忽略每层的 cv 限定符
  • 能通过结果触及的每个字节都能通过 p 触及(如果字节在与 y 指针可以互相转换的对象 z 的存储内,或在以 z 为元素的立即外围数组内,那么能通过指向对象 y 的指针触及这些字节)。

那么 std::launder(p) 返回 T* 类型的值,它指向对象 x。否则行为未定义。

如果 T 是函数类型或(可有 cv 限定的)void,那么程序非良构。

std::launder 可用于核心常量表达式,当且仅当它的(在转换后的)实参的值在函数调用的位置可使用。换言之,std::launder 不放松常量求值中的限制。

注解

std::launder 在它的实参上无效果。必须用它的返回值访问对象。从而,舍弃返回值始终是错误。

std::launder 的典型用途包括:

  • 获得指向在同类型既存对象的存储中创建的对象的指针,这里不能重用指向旧对象的指针(例如,因为任一对象为基类子对象);
  • 获得指向对象的指针,该对象由布置 new 从指向为该对象提供存储的对象的指针创建。

可触及性 限制确保不能用 std::launder 访问不可通过原指针访问的字节,从而干涉编译器的逃逸分析。

int x[10];
auto p = std::launder(reinterpret_cast<int(*)[10]>(&x[0])); // OK
 
int x2[2][10];
auto p2 = std::launder(reinterpret_cast<int(*)[10]>(&x2[0][0])); 
// 未定义行为:可通过产生的指向 x2[0] 的指针触及 x2[1],但不可从源触及
 
struct X { int a[10]; } x3, x4[2]; // 标准布局;假定无填充
auto p3 = std::launder(reinterpret_cast<int(*)[10]>(&x3.a[0])); // OK
auto p4 = std::launder(reinterpret_cast<int(*)[10]>(&x4[0].a[0]));
// 未定义行为:可通过产生的指向 x4[0].a 的指针
// (它与 x4[0] 指针间可转换)触及 x4[1],但不可从源触及
 
struct Y { int a[10]; double y; } x5;
auto p5 = std::launder(reinterpret_cast<int(*)[10]>(&x5.a[0])); 
// 未定义行为:可通过产生的指向 x5.a 的指针触及 x5.y,但不可从源触及

示例

#include <cassert>
#include <cstddef>
#include <new>
 
struct Base
{
    virtual int transmogrify();
};
 
struct Derived : Base
{
    int transmogrify() override
    {
        new(this) Base;
        return 2;
    }
};
 
int Base::transmogrify()
{
    new(this) Derived;
    return 1;
}
 
static_assert(sizeof(Derived) == sizeof(Base));
 
int main()
{
    // 情况1:新对象无法为透明可替换,因为它是基类子对象而旧对象是完整对象。
    Base base;
    int n = base.transmogrify();
    // int m = base.transmogrify(); // 未定义行为
    int m = std::launder(&base)->transmogrify(); // OK
    assert(m + n == 3);
 
    // 情况2:通过指向字节数组的指针访问存储为该数组所提供的新对象。
    struct Y { int z; };
    alignas(Y) std::byte s[sizeof(Y)];
    Y* q = new(&s) Y{2};
    const int f = reinterpret_cast<Y*>(&s)->z; // 类成员访问为未定义行为:
                                               // reinterpret_cast<Y*>(&s) 拥有值
                                               // “指向 s 的指针”而不指向 Y 对象
    const int g = q->z; // OK
    const int h = std::launder(reinterpret_cast<Y*>(&s))->z; // OK
 
    [](...){}(f, g, h); // 压制 [[maybe_unused]] 效果
}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
LWG 2859 C++17 可触及 的定义未考虑来自指针可互转换的对象的指针算术 已考虑
LWG 3495 C++17 std::launder 可以在常量表达式中令指向不活跃成员的指针可解引用 已禁止