new 表达式

来自cppreference.com
< cpp‎ | language
 
C++
 
C++ 语言
 
表达式
概述
值类别（左值 lvalue、右值 rvalue、亡值 xvalue）
求值顺序（序列点）
常量表达式
潜在求值表达式
初等表达式
lambda 表达式(C++11)
字面量
整数字面量
浮点字面量
布尔字面量
字符字面量，包含转义序列
字符串字面量
空指针字面量(C++11)
用户定义字面量(C++11)
运算符
赋值运算符： a=b，a+=b，a-=b，a*=b，a/=b，a%=b，a&=b，a|=b，a^=b，a<<=b，a>>=b
自增与自减：++a，--a，a++，a--
算术运算符： +a，-a，a+b，a-b，a*b，a/b，a%b，~a，a&b，a|b，a^b，a<<b，a>>b
逻辑运算符：a||b，a&&b，!a
比较运算符：a==b，a!=b，a<b，a>b，a<=b，a>=b，a<=>b(C++20)
成员访问运算符：a[b]，*a，&a，a->b，a.b，a->*b，a.*b
其他运算符：a(...)，a,b，a?b:c
new 表达式
delete 表达式
throw 表达式
alignof
sizeof
sizeof...(C++11)
typeid
noexcept(C++11)
折叠表达式(C++17)
运算符的代用表示
优先级和结合性
运算符重载
默认比较(C++20)
类型转换
隐式转换
一般算术转换
const_cast
static_cast
reinterpret_cast
dynamic_cast
显式转换 (T)a, T(a)
用户定义转换
 

创建并初始化拥有动态存储期的对象，这些对象的生存期不受它们创建时所在的作用域限制。

语法

::(可选) new ( 类型 ) 初始化器(可选) (1)
::(可选) new new类型 初始化器(可选) (2)
::(可选) new (布置参数) ( 类型 ) 初始化器(可选) (3)
::(可选) new (布置参数) new类型 初始化器(可选) (4)
1) 尝试创建类型标识 类型 所指代的类型的一个对象，它可以是数组类型，可以包含占位符类型说明符 (C++11 起)，或包含将由类模板实参推导推出的类模板名 (C++17 起)。
2) 同(1)，但 new类型 不能包含括号：
new int(*[10])();    // 错误：解析成 (new int) (*[10]) ()
new (int (*[10])()); // OK：分配 10 个函数指针的数组
另外，new类型 是贪心的：它将包含可以成为声明符一部分的所有记号： 
new int + 1; // OK：解析成 (new int) + 1，增加 new int 所返回的指针
new int * 1; // 错误：解析成 (new int*) (1)
3) 同(1)，但会向分配函数提供额外实参，见布置 new
4) 同(2)，但会向分配函数提供额外实参


符合下列条件之一时，必须要有 初始化器：

  • 类型 或 new类型 中使用了占位符，即 auto 或 decltype(auto) (C++14 起)，可能与类型约束结合 (C++20 起)
(C++11 起)
  • 类型 或 new类型 中使用了类模板，且该模板有实参需要被推导
(C++17 起)
double* p = new double[]{1, 2, 3}; // 创建 double[3] 类型的数组
auto p = new auto('c');            // 创建单个 char 类型的对象。p 是一个 char*
 
auto q = new std::integral auto(1);         // OK: q 是一个 int*
auto q = new std::floating_point auto(true) // 错误：不满足类型约束
 
auto r = new std::pair(1, true); // OK: r 是一个 std::pair<int, bool>*
auto r = new std::vector;        // 错误：无法推导元素类型

解释

new 表达式尝试申请存储空间，并在已申请的存储空间上，尝试构造并初始化一个无名的对象或对象数组。new 表达式返回一个指向它构造的对象或者指向数组初始元素的纯右值指针。

如果 类型 或 new类型 是数组类型，那么它第一维之外的所有维都必须指定为正的整数常量表达式 (C++14 前)类型是 std::size_t 的经转换的常量表达式 (C++14 起)，但（仅当使用无括号语法 (2) 时）第一维可以是整数类型、枚举类型或拥有单个到整数或枚举类型的非 explicit 转换函数的类类型 (C++14 前)任何能转换成 std::size_t 的表达式 (C++14 起)。这是唯一直接创建大小在运行时定义的数组的方法，这种数组常被称作动态数组： 

int n = 42;
double a[n][5]; // 错误
auto p1 = new double[n][5];   // OK
auto p2 = new double[5][n];   // 错误：只有第一维可以不是常量
auto p3 = new (double[n][5]); // 错误：语法 (1) 不能用于动态数组

如果第一维中的值（如果需要则转换到整数或枚举类型）为负，那么行为未定义。

(C++11 前)

下列情况中指定第一维的表达式是错误的：

  • 表达式是非类类型，且它的值在转换到 std::size_t 前是负的；
  • 表达式拥有类类型，且它的值在用户定义转换函数后，在第二次标准转换前是负的；
  • 表达式的值大于某个实现定义极限；
  • 其值小于花括号初始化器中提供的数组元素数量（也包含字符串字面量中的终止 '\0'）。

如果第一维值因以上任何原因而错误，

(C++11 起)

第一维为零是可接受的，分配函数也会被调用。

注意：std::vector 提供了与一维的动态数组类似的功能。

分配

new 表达式通过调用适当的分配函数分配存储。如果 类型 或 new类型 是非数组类型，那么函数名是 operator new。如果 类型 或 new类型 是数组类型，那么函数名是 operator new[]。

如分配函数中所描述，C++ 程序可提供这些函数的全局和类特有替换函数。如果 new 表达式以 :: 运算符开始，如 ::new T 或 ::new T[n]，那么忽略类特有替换函数（在全局作用域中查找函数）。否则，如果 T 是类类型，那么就会从 T 的类作用域中开始查找。

在调用分配函数时，new 表达式将请求的字节数作为 std::size_t 类型的第一参数传递给它，该参数对于非数组 T 恰好是 sizeof(T)。

数组的分配中可能带有一个未指明的开销（overhead），且每次调用 new 的这个开销可能不同，除非选择的分配函数是标准非分配形式。new 表达式所返回的指针等于分配函数所返回的指针加上该值。许多实现使用数组开销存储数组中的对象数量，delete[] 表达式会用它进行正确数量的析构函数调用。另外，如果用 new 分配 char、unsigned char 或 std::byte (C++17 起)的数组，那么它可能从分配函数请求额外内存，以此保证所有不大于请求数组大小的类型的对象在放入所分配的数组中时能够正确对齐。

允许将各个 new 表达式通过可替换分配函数所进行的分配予以省略或合并。在省略的情况下，存储可以由编译器提供，而无需调用分配函数（这也允许优化掉不使用的 new 表达式）。在合并的情况下且满足以下所有条件时，new 表达式 E1 所做的分配可以被扩展，以提供另一个 new 表达式 E2 的额外存储：

1) E1 所分配对象的生存期严格包含 E2 所分配对象的生存期，
2) E1 与 E2 将调用同一可替换全局分配函数
3) 对于抛出异常的分配函数，E1 与 E2 中的异常将首先被同一处理块捕捉。
注意此优化仅在使用 new 表达式，而非调用可替换分配函数的任何其他方法时允许：delete [] new int[10]; 能被优化掉，但 operator delete(operator new(10)); 不能。		 (C++14 起)

在常量表达式求值期间，始终省略对分配函数的调用。只有在其他情况下调用可替换全局分配函数的 new 表达式能在常量表达式中求值。

(C++20 起)
布置 new

如果提供了 布置参数，那么它们会作为额外实参传递给分配函数。这些分配函数被称作“布置 new”，这来源于标准分配函数 void* operator new(std::size_t, void*)，它直接返回未更改的第二实参。它被用于在已分配的存储中构造对象： 

// 在任何块作用域内……
{
    // 静态分配拥有自动存储期的存储，对任何对象类型 `T` 足够大。
    alignas(T) unsigned char buf[sizeof(T)];
 
    T* tptr = new(buf) T; // 构造一个 `T` 对象，将它直接置于
                          // 你预分配的位于内存地址 `buf` 的存储。
 
    tptr->~T();           // 如果程序依赖对象的析构函数的副作用，你必须**手动**调用它。
}                         // 离开此块作用域自动解分配 `buf` 。

注意：分配器 (Allocator) 类的各成员函数封装了此功能。

在分配具有超出 __STDCPP_DEFAULT_NEW_ALIGNMENT__ 的对齐要求的对象或这种对象的数组时，new 表达式将对齐要求作为第二实参（以 std::align_val_t 包装）传递给分配函数（对于布置形式，布置参数 被放在对齐之后，作为第三、第四个实参等）。如果重载决议失败（当定义了具有不同签名的类特有分配函数时，会发生此种情况，因为它隐藏了全局版本），那么会以实参列表中不带对齐再次尝试进行重载决议。这允许不关心对齐的类特有分配函数优先于全局的关心对齐的分配函数。

(C++17 起)
new T;      // 调用 operator new(sizeof(T))
            // (C++17) 或 operator new(sizeof(T), std::align_val_t(alignof(T))))
new T[5];   // 调用 operator new[](sizeof(T)*5 + overhead)
            // (C++17) 或 operator new(sizeof(T)*5+overhead, std::align_val_t(alignof(T))))
new(2,f) T; // 调用 operator new(sizeof(T), 2, f)
            // (C++17) 或 operator new(sizeof(T), std::align_val_t(alignof(T)), 2, f)

如果不抛出的分配函数（例如 new(std::nothrow) T 所选择的）因为分配失败返回空指针，那么 new 表达式会立即返回，而不会试图初始化对象或调用解分配函数。如果将空指针作为实参传给不分配的布置 new 表达式，而这会使得被选择的标准不分配布置分配函数返回空指针，那么行为未定义。

构造

new 表达式所创建的对象按照下列规则初始化：

  • 对于非数组的 类型 或 new类型，在所得内存区域中构造单个对象。
  • 如果没有 初始化器，那么对象会被默认初始化。
  • 如果 初始化器 是带括号的实参列表，那么对象会被直接初始化。
  • 如果 初始化器 是花括号包围的实参列表，那么对象会被列表初始化。
(C++11 起)
  • 如果 类型 或 new类型 是数组类型，那么初始化一个数组的对象。
  • 如果没有 初始化器，那么每个元素都会被默认初始化。
  • 如果 初始化器 是一对空括号，那么每个元素被值初始化。
  • 如果 初始化器 是花括号包围的实参列表，那么数组会被聚合初始化。
(C++11 起)
  • 如果 初始化器 是带括号的实参列表，那么数组会被聚合初始化。
(C++20 起)

如果初始化因抛出异常而终止（例如来自构造函数），那么 new 表达式在已经分配了任何存储的情况下会调用适当的解分配函数：对于非数组 类型 或 new类型 是 operator delete，而对于数组 类型 或 new类型 是 operator delete[]。如果 new 表达式使用 ::new 语法，那么会在全局作用域查找解分配函数，否则如果 T 是类类型，那么会在 T 的作用域查找。如果失败的是常规（非布置）分配函数，那么会遵循 delete 表达式中所述的规则查找解分配函数。对于失败的布置 new，与之匹配的解分配函数中除第一个外的所有形参的类型，必须与布置 new 的各形参类型相同。对解分配函数的调用中，将先前从分配函数取得的值作为第一实参，将对齐作为可选的对齐参数， (C++17 起)并将 布置参数（如果存在）作为额外的布置参数。如果找不到解分配函数，那么不会解分配内存。

内存泄漏

new 表达式所创建的对象（拥有动态存储期的对象）会持续到将 new 表达式所返回的指针用于匹配的 delete 表达式之时。如果指针的原值丢失，那么对象不可达且无法解分配：发生内存泄漏 (memory leak)。

对指针赋值时可能发生： 

int* p = new int(7); // 动态分配的 int 带值 7
p = nullptr; // 内存泄漏

或指针离开作用域： 

void f()
{
    int* p = new int(7);
} // 内存泄漏

或因为异常： 

void f()
{
    int* p = new int(7);
    g();      // 可能抛出异常
    delete p; // 如果没有异常则 ok
} // 如果 g() 抛出异常则内存泄漏

为了简化动态分配的对象管理，通常将 new 表达式的结果存储于智能指针中：std::auto_ptr (C++17 前)std::unique_ptr 或 std::shared_ptr (C++11 起)。这些指针保证在上述情形中执行 delete 表达式。

关键词

new

注解

Itanium C++ ABI 要求数组分配开销在创建的数组元素类型为可平凡析构时为零。MSVC 也是这样。

某些实现（如 VS 2019 v16.7 前的 MSVC）在元素类型非可平凡析构的情况下非分配布置数组 new 时会有非零的数组分配开销，这从 CWG2382 起不再遵从标准。

创建 char、unsigned char 或 std::byte (C++17 起) 的数组的非分配布置数组 new 能用于在给定的存储区域隐式创建对象：它结束与该数组重叠的对象的生存期，然后在该数组中隐式创建隐式生存期类型的对象。

缺陷报告

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

缺陷报告 应用于 出版时的行为 正确行为
CWG 74 C++98 第一维中的值必须拥有整数类型 容许枚举类型
CWG 299 C++98 第一维中的值必须拥有整数或枚举类型 容许有唯一的到整数或枚举
类型的转换函数的类类型
CWG 624 C++98 未指明要分配的对象的大小超出实现定义的限制时的行为 此时不会分配存储，并且会抛出异常
CWG 1748 C++98 要求非分配布置 new 检查实参是否为空 空实参导致未定义行为
CWG 1992 C++11 new (std::nothrow) int[N] 可能
会抛出 std::bad_array_new_length 		改为返回空指针
CWG 2382 C++98 非分配布置数组 new 能要求分配开销 不允许这种分配开销
CWG 2392 C++11 即使第一维没有潜在求值，程序也可能会非良构 此时良构
P1009R2 C++11 new 表达式中不能推导数组边界 可以推导

参阅

来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/language/new&oldid=77592”