std::launder

来自cppreference.com
< cpp‎ | utility
定义于头文件 <new>
template <class T>
constexpr T* launder(T* p) noexcept;
(C++17 起)
(C++20 前)
template <class T>
[[nodiscard]] constexpr T* launder(T* p) noexcept;
(C++20 起)

获得指向位于 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 的典型用途包括:

  • 获得指向在同类型既存对象的存储中创建的对象的指针,这里不能重用指向旧对象的指针,因为该对象拥有 const 或引用数据成员,或任一对象为基类子对象;
  • 获得指向对象的指针,该对象由布置 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 <new>
#include <cstddef>
#include <cassert>
 
struct X {
  const int n; // 注意: X 拥有 const 成员
  int m;
};
 
struct Y {
  int z;
};
 
struct A { 
    virtual int transmogrify();
};
 
struct B : A {
    int transmogrify() override { new(this) A; return 2; }
};
 
int A::transmogrify() { new(this) B; return 1; }
 
static_assert(sizeof(B) == sizeof(A));
 
int main()
{
  X *p = new X{3, 4};
  const int a = p->n;
  X* np = new (p) X{5, 6};    // p 不指向新对象,因为 X::n 为 const ,而 np 指向新对象
  const int b = p->n; // 未定义行为
  const int c = p->m; // 未定义行为(即使 m 为非 const ,也不能用 p )
  const int d = std::launder(p)->n; // OK : std::launder(p) 指向新对象
  const int e = np->n; // OK
 
  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
 
  A i;
  int n = i.transmogrify();
  // int m = i.transmogrify(); // 未定义行为
  int m = std::launder(&i)->transmogrify(); // OK
  assert(m + n == 3);
}