Namespaces
Variants

std:: start_lifetime_as, std:: start_lifetime_as_array

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Explicit lifetime management
start_lifetime_as
(C++23)
start_lifetime_as_array
(C++23)
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
定义于头文件 <memory>
std::start_lifetime_as
template < class T >
T * start_lifetime_as ( void * p ) noexcept ;
(1) (C++23 起)
template < class T >
const T * start_lifetime_as ( const void * p ) noexcept ;
(2) (C++23 起)
template < class T >
volatile T * start_lifetime_as ( volatile void * p ) noexcept ;
(3) (C++23 起)
template < class T >
const volatile T * start_lifetime_as ( const volatile void * p ) noexcept ;
(4) (C++23 起)
std::start_lifetime_as_array
template < class T >
T * start_lifetime_as_array ( void * p, std:: size_t n ) noexcept ;
(5) (C++23 起)
template < class T >

const T * start_lifetime_as_array ( const void * p,

std:: size_t n ) noexcept ;
(6) (C++23 起)
template < class T >

volatile T * start_lifetime_as_array ( volatile void * p,

std:: size_t n ) noexcept ;
(7) (C++23 起)
template < class T >

const volatile T * start_lifetime_as_array ( const volatile void * p,

std:: size_t n ) noexcept ;
(8) (C++23 起)
1-4) 隐式创建 一个完整的 T 类型对象（其地址为 p ）及其内部嵌套对象。对于每个创建的 可平凡复制 类型 U 的对象 obj ，其值的确定方式与调用 std:: bit_cast < U > ( E ) 相同，但实际不会访问存储空间，其中 E 是表示 obj 的 U 类型左值。否则，此类创建对象的值是未指定的。
  • [ p , ( char * ) p + sizeof ( T ) ) 不表示已分配存储区域，或该区域不是通过 p 可访问存储区域的子集，或
  • 该区域未按 T 的要求进行适当对齐。
  • 注意未指定的值可能是不确定的。
5-8) 隐式创建 一个元素类型为 T 且长度为 n 的数组。具体而言，若 n > 0 为 true ，则等价于 std :: start_lifetime_as < U > ( p ) ，其中 U 是“ n 个 T 的数组”类型。否则该函数无效果。
  • T 应为 完整类型 ，否则程序非良构。
  • 在下列情况下行为未定义：
  • 非空的 p 未按 T 数组的要求适当对齐，或
  • n <= std:: size_t ( - 1 ) / sizeof ( T ) 为 false ，或
  • n > 0 且 [ ( char * ) p , ( char * ) p + ( n * sizeof ( T ) ) ) 不表示可通过 p 访问的存储区域内的已分配存储子集。

目录

参数

p - 指向由对象组成的内存区域的地址
n - 要创建的数组元素数量

返回值

1-4) 指向如上所述完整对象的指针。
5-8) 指向所创建数组首元素的指针（若存在）；否则，返回与 p 比较相等的指针。

注释

new ( void_ptr ) unsigned char [ size ] 或 new ( void_ptr ) std:: byte [ size ] 可作为 std::start_lifetime_as 的无类型版本使用，但不会保留对象表示形式。

std :: start_lifetime_as 处理非数组类型以及已知边界的数组，而 std :: start_lifetime_as_array 则处理未知边界的数组。

功能测试 宏 值 标准 功能
__cpp_lib_start_lifetime_as 202207L (C++23) 显式生命周期管理

示例

运行此代码 
#include <complex>
#include <iostream>
#include <memory>
int main()
{
    alignas(std::complex<float>) unsigned char network_data[sizeof(std::complex<float>)]
    {
        0xcd, 0xcc, 0xcc, 0x3d, 0xcd, 0xcc, 0x4c, 0x3e
    };
//  auto d = *reinterpret_cast<std::complex<float>*>(network_data);
//  std::cout << d << '\n'; // 未定义行为：network_data 未指向 complex<float>
//  auto d1 = *std::launder(reinterpret_cast<std::complex<float>*>(network_data));
//  std::cout << d1 << '\n'; // 未定义行为：隐式创建的对象具有动态存储期
//                                  且初始值不确定，即使提供存储的数组
//                                  具有确定的字节值
//                                  另见 CWG2721
    auto d2 = *std::start_lifetime_as<std::complex<float>>(network_data);
    std::cout << d2 << '\n'; // 正确
}

可能的输出： 

(0.1,0.2)

参考文献

  • C++23 标准 (ISO/IEC 14882:2024):
  • 20.2.6 显式生命周期管理 [obj.lifetime]

参见

(C++20)
将一种类型的对象表示重新解释为另一种类型的对象表示
(函数模板)
(C++20)
将 span 转换为其底层字节的视图
(函数模板)