C/C++编程：new表达式

红太狼 2022-11-10 10:40 480阅读 0赞

*  创建并初始化拥有`动态存储期`的对象，这些对象的**生存期不受它们创建时所在的作用域限制**
 *  动态存储器对象的存储是通过使用`动态内存分配`函数来按请求进行分配和解分配的
 *  new表达式尝试申请空间，并在已申请的存储空间上，尝试构造并初始化一个无名的对象或者对象数组。
 *  new表达式返回一个指向其所构造的对象或者对象数组的纯右值指针

# 语法 #

::(可选) new (布置参数)(可选) (类型) 初始化器(可选)	(1)	
    ::(可选) new (布置参数)(可选)  类型  初始化器(可选)	(2)

0、

int *pi = new int(6);
    double  *pd = new double(99.99);
    int *pin = new int{
        };
    double  *pdn = new double{
        99.99};
    
    struct where{
        
        double  x;
        double  y;
        double  z;
    };
    
    where *one = new where{
        2.5, 5.3, 9.3};
    int *ar = new int[4]{
        1, 2, 3, 4};

1、类型不能包括`()`

new int(*[10])(); // 错误：分析成 (new int) (*[10]) ()
    new (int (*[10])()); // OK：分配 10 个函数指针的数组

2、无括号的 类型 是贪心的：它将包含可以是声明符一部分的所有记号：

new int + 1; // OK：分析成 (new int) + 1，增加 new int 所返回的指针
    new int * 1; // 错误：分析成 (new int*) (1)

3、

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;        // 错误：无法推导元素类型

4、new一个**动态数组**（这是唯一直接创建大小在运行时定义的数组的方法）

*  第一维可以是整数类型、枚举类型、拥有单个到整数或枚举类型的非 explicit 转换函数的类类型 (C++14 前)、任何能转换成 std::size\_t 的表达式
 *  第一维之外的所有维都必须指定**为正的整数常量表达式(C++14 前)**、**类型为 std::size\_t 的经转换的常量表达式 (C++14 起)**
 *  第一维为零是可接受的，分配函数也会被调用。
 *  注意：std::vector 提供了与一维的动态数组类似的功能。
 *  > 常量表达式：定义能在编译时求值的表达式

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) 不能用于动态数组

# 分配 #

new 表达式通过调用 [分配函数][Link 1]适当的分配存储

*  若 类型 是非数组类型，则函数名是 operator new。
 *  若 类型 是数组类型，则函数名是 operator new\[\]。

正如**分配函数**中所诉，C++程序可提供这些函数的全局和类特有的替换函数

*  若 new 表达式以可选的 :: 运算符开始，如 ::new T 或 ::new T\[n\]，则忽略类特有替换函数（在全局作用域中查找函数）
 *  否则，若 T 是类类型，则从 T 的类作用域中开始查找。

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

数组的分配中可能带有一个未指明的开销(`overhead`)，而且每次调用new的这个开销可能不同，除非选择的分配函数是标准非分配形式。new 表达式所返回的指针等于分配函数所返回的指针加上该值。

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)

许多实现使用数组开销的存储数组中的对象数量，它为`delete[]`表达式所用，以进行正确数量的析构函数调用。

另外，若 new 被用于分配 char、unsigned char 或 std::byte (C++17 起)的数组，则它可能从分配函数请求额外内存，以此保证所有不大于请求数组大小的类型的对象，当将其放入所分配的数组中时能够正确对齐。

# 构造 #

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

>  *  对于非数组的类型，在所得内存区域中构造单个对象
>     
>      *  如果没有初始化器，则对象被`默认初始化`
>      *  如果初始化器是带括号的实参列表，则对象被`直接初始化`
>      *  如果初始化器是花括号包围的实参列表，则对象被`列表初始化`（C++11起）
>  *  如果类型是数组类型，则初始化一个数组的对象
>     
>      *  如果没有初始化器，则对象被`默认初始化`
>      *  如果初始化器是一对空括号，则每个元素被`值初始化`
>      *  若 初始化器 是花括号包围的实参列表，则数组被`聚合初始化`。

如果初始化因抛出异常而终止（例如来自构造函数），则如果new表达式中已经分配了任何存储，则它将调用适当的解分配函数(也就是delete)

>  *  对于非数组类型，调用`operator delete`
>  *  对于数组类型，调用`operator delete[]`

若 new 表达式使用`::new` 语法，则在全局作用域查找解分配函数，否则若 T 是类类型，则在 T 的作用域查找。

>  *  若失败的是常规（非布局）分配函数，则遵循 delete 表达式中所述的规则查找解分配函数。
>  *  对于失败的布局new，与之匹配的解分配函数中除第一个外的所有形参的类型，必须与布置 new 的各形参类型相同。（？？？）对解分配函数的调用中，将先前从分配函数取得的值作为第一实参，将对齐作为可选的对齐参数， (C++17 起)并将  
>     布置参数（若存在）作为额外的布置参数。若找不到解分配函数，则不解分配内存。

**new表达式创建的对象(也就是拥有动态存储期的对象)，持续到将new表达式所返回的指针用于匹配的[ delete 表达式][delete]之时。****如果指针的原值丢失，则对象变为不可达而且无法解分配，也就是发生内存泄漏**

>  *  对指针赋值时可能发生：
> 
>     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表达式的结果存储在`智能指针中`，这些指针**保证在上述情形中执行delete表达式**

# 举例 #

> 分配函数&&释放函数

void *operator new(std::size_t);
    void *operator new[](std::size_t);
    
    void operator delete(void *);
    void operator delete[](void *);

`std::size_t`是一个`typedef`，对应于合适的整形。比如：

int *pi = new int;

将会被转换为：

int *pi = new(sizeof(int));

而：

int *pa = new int[40];

将会被转换为：

int *pa = new(40 * sizeof(int));

当然，使用new的语句也可能会包含初始值，因此，使用new运算符时，可能不仅仅是调用new()函数。

同样：

delete pi;

将被转化为：

delete (pi);

# 和动态数组相关的特性 #

**我们通常称使用`new T[]`形式分配的内存为动态数组**

> 使用初始化列表初始化

可以像一般的数组一样，使用初始化列表对动态数组进行初始化，代码如下：

int *p = new int[9]{
        1, 2, 3, 4, 5, 6, 7, 8, 9};
      for(int i = 0; i < 9; i++){
        
          cout << p[i] << "\t";
      }
      delete [] p;

![在这里插入图片描述][20210323203706970.png]

> 和数组的区别

之所以叫动态数组，一是它的内存是动态分配的，还有就是它可以像数组一样使用。但是动态数组和数组还是有一些区别，例如编译器无法从数组名获知数组的大小信息。下面的代码就不能正确动作：

int *p = new int[9]{
        1, 2, 3, 4, 5, 6, 7, 8, 9};
        for(int i = 0; i < sizeof(p)/ sizeof(p[0]); i++){
        
            cout << p[i] << "\t";
        }
        delete [] p;

同样地，C++11中引入的范围for也被不支持。下面的代码直接会发生编译错误：  
![在这里插入图片描述][20210323204027261.png]  
但是这件事有一个例外，动态申请的对象数组在释放内存时，如果需要调用析构函数，编译器会在动态数组的前面保存动态数组的大小信息，比如下面的例子：

struct demo{
        
            demo(){
        }
            void test(){
        
                cout << "test()\n";
            }
            ~demo(){
        
                cout << " ~demo\n";
            }
        };

在动态分配内存之后，可以像下面的代码一样取得数组的大小：

demo *pd = new demo[10];
        int count = *((int *)pd - 1);
        for(int i = 0; i < count; i++){
        
            pd[i].test();
        }
        delete[] pd;

有一点值得注意的是，这个方法有可能依赖于编译器的实现，所以在作者不能保证在所有的编译器中都能正常动作。

# 布局new #

> 作用：

通常，new负责再堆中找到一个能够满足要求的内存卡。new运算符还有另一种变体，被称为定位new，它让您能够指定要使用的位置。可以使用这种设置其内存管理规程、处理需要通过特定地址进行访问的硬件或者再特定位置创建对象。

#include<new>
    struct chaff{
        
    	char dross[20];
    	int slog;
    };
    
    char buffer1[50];
    char buffer2[500];
    
    int main(){
        
    	chaff *p1, *p2;
    	int *p3, *p4;
    
    	p1 = new chaff; //堆上分配空间给struct
    	p3 = new int[20]; // 堆上分配空间给array
    
    	p2 = new(buffer1)chaff; //在buffer1上分配空间给struct
    	p4 = new(buffer2)int[20]; //在buffer2上分配空间给array
    }

class Widget{
        
    public:
    	Widget(int widgetSize);
    };
    
    Widget * constructWidgetInBuffer(void *buffer, int widgetSize){
        
    	return new(buffer)Widget(widgetSize);
    }

对于`new(buffer)Widget(widgetSize)`，它调用的就是布局new：

void *operator_new(size_t, void * location){
          //size_t没有名字，为了防止编译器发出警告说它没有被使用。
    	return location;
    }

> 使用场景

传统的new操作符只能在动态内存中得到空间，如果我们想要重一个静态内存中得到一个空间，该怎么做呢？

就用**布局new操作符**

#include <iostream>
    #include <new>
    using namespace std;
    int main()
    {
        
    	char buffer[10];
    	char *p = new (buffer) char[sizeof(buffer)];
    	p[9] = 'a';
    	cout<<buffer[9];
        return 0;
    }

p指针指向了buffer的内存空间，可以直接对buffer进行写值，而且p等于buffer数组的首地址。

注意：这里不能对p进行释放空间。

**布局new操作符，能够让你指定要使用的位置。**

> 什么叫做布局new（也叫做定位new）

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

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

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

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

# \# new操作符和new操作的区别 #

对于：

string *ps = new string("memory mangement");

这里的new是`new operator`(new操作符)。这个操作符就像sizeof一样是语言内置的，你不能改变它的含义，它的功能总是一样的。它要完成的功能分为两部分：

*  第一部分是分配足够的内存以便容纳所需类型的对象
 *  第二部分是它调用构造函数初始化内存中的对象。

new操作符总是做这两件事情，你不能以任何方式改变它的行为。

你所能改变的是如何为对象分配内存。new操作符调用一个函数来完成必需的内存分配。你能够重写或者重载这个函数来改变它的行为。new操作符为分配内存所调用函数的名字是`operator new`(new操作)。

函数operator new通常这样声明：

void * operator new(size_t size);

返回值类型是void\*，因为这个函数返回一个未经处理(raw)的指针，未初始化的内存（如果你喜欢，也可以写一种operator new函数，在返回一个指针之前能够初始化内存以存储一些数据，但是一般不这么做）。你能增加额外的参数重载operator new，但是第一个参数类型必须是size\_t。

你一般不会直接调用operator new，但是一旦这么做，你可以像调用其他函数一样调用它：

void *rawMemory = operator new(sizeof(string));

操作符operator new将返回一个指针，指向一块足够容纳一个string类型对象的内存。

就像malloc一样，operator new的职责只是分配内存。它对构造函数一无所知。operator new所了解的是内存分配。

# 注意 #

*  如果在new表达式中使用\[\]，必须在相应的delete表达式也使用\[\]；
 *  如果没有在newnew表达式中使用\[\]，一定不要在delete表达式中使用\[\]
 *  如果你想在堆上分配一个对象，应该用new操作符。它即分配对象又为对象调用构造函数。如果你仅仅想分配内存，就应调用operator new函数：它不会调用构造函数。如果你想定制自己的在堆对象被建立时的内存分配过程，你应该写你自己的operator new函数，然后使用new操作符，new操作符会调用你定义的operator new。如果你想在一块已经获得的指针的内存中建立一个对象，应该用placement new。

[Link 1]: https://zh.cppreference.com/w/cpp/memory/new/operator_new
[delete]: https://zh.cppreference.com/w/cpp/language/delete
[20210323203706970.png]: /images/20221023/ab2c5ebef3c14786a47d0a26dc526ac6.png
[20210323204027261.png]: /images/20221023/9ea0afefe39741d4b554a8313a94194e.png