new 和 delete

new 和 delete 可用于动态创建和释放对象。

尽量用 new 和 delete 而不用 malloc 和 free。malloc 和 free(及其变体)会产生问题的原因在于它们太简单:他们不知道构造函数和析构函数。

动态对象

定义

动态创建对象时,只需指定其数据类型,而不必为该对象命名。取而代之的是,new 表达式返回指向新创建对象的指针,我们通过该指针来访问此对象:

1
2
3
int i; // named, uninitialized int variable
int *pi = new int; // pi points to dynamically allocated,
// unnamed, uninitialized int

这个 new 表达式在自由存储区中分配创建了一个整型对象,并返回此对象的地址,并用该地址初始化指针 pi。

初始化

直接初始化

动态创建的对象可用初始化变量的方式实现初始化:

1
2
3
4
int i(1024); // value of i is 1024
int *pi = new int(1024); // object to which pi points is 1024
string s(10, '9'); // value of s is "9999999999"
string *ps = new string(10, '9'); // *ps is "9999999999"

默认初始化

如果不提供显式初始化,动态创建的对象与在函数内定义的变量初始化方式相同。对于类类型的对象,用该类的默认构造函数初始化;而内置类型的对象则无初始化。

1
2
string *ps = new string; // initialized to empty string
int *pi = new int; // pi points to an uninitialized int

通常,除了对其赋值之外,对未初始化的对象所关联的值的任何使用都是没有定义的。

正如我们(几乎)总是要初始化定义为变量的对象一样,在动态创建对象时,(几乎)总是对它做初始化也是一个好办法。

值初始化

同样也可对动态创建的对象做值初始化(value-initialize):

1
2
3
string *ps = new string(); // initialized to empty string
int *pi = new int(); // pi points to an int value-initialized to 0
cls *pc = new cls(); // pc points to a value-initialized object of type cls

对于提供了默认构造函数的类类型(例如 string),没有必要对其对象进行值初始化:无论程序是明确地不初始化还是要求进行值初始化,都会自动调用其默认构造函数初始化该对象。而对于内置类型或没有定义默认构造函数的类型,采用不同初始化方式则有显著的差别:

1
2
int *pi = new int; // pi points to an uninitialized int
int *pi = new int(); // pi points to an int value-initialized to 0

第一个语句的 int 型变量没有初始化,而第二个语句的 int 型变量则被初始化为 0。

释放

动态创建的对象用完后,程序员必须显式地将该对象占用的内存返回给自由存储区。C++ 提供了 delete 表达式释放指针所指向的地址空间。

1
delete pi;

该命令释放 pi 指向的 int 型对象所占用的内存空间。

如果指针指向不是用 new 分配的内存地址,则在该指针上使用 delete 是不合法的。

C++ 没有明确定义如何释放指向不是用 new 分配的内存地址的指针。下面提供了一些安全的和不安全的 delete expressions 表达式。

1
2
3
4
5
6
7
int i;
int *pi = &i;
string str = "dwarves";
double *pd = new double(33);
delete str; // error: str is not a dynamic object
delete pi; // error: pi refers to a local
delete pd; // ok

值得注意的是:编译器可能会拒绝编译 str 的 delete 语句。编译器知道 str 并不是一个指针,因此会在编译时就能检查出这个错误。第二个错误则比较隐蔽:通常来说,编译器不能断定一个指针指向什么类型的对象,因此尽管这个语句是错误的,但在大部分编译器上仍能通过。

零值指针的删除

如果指针的值为 0,则在其上做 delete 操作是合法的:

1
2
int *ip = 0;
delete ip; // ok: always ok to delete a pointer that is equal to 0

C++ 保证:删除 0 值的指针是安全的(见 《Effective C++》 条款8)。

悬垂指针

执行语句

1
delete p;

后,p 变成没有定义。在很多机器上,尽管 p 没有定义,但 仍然存放了它之前所指向对象的地址 ,然而 p 所指向的内存已经被释放,因此 p 不再有效。 删除指针后,该指针变成 悬垂指针 。悬垂指针指向曾经存放对象的内存,但该对象已经不再存在了。悬垂指针往往导致程序错误,而且很难检测出来。

一旦删除了指针所指向的对象,立即将指针置为 0,这样就非常清楚地表明指针不再指向任何对象。

const 对象的动态分配和回收

创建

C++ 允许动态创建 const 对象:

1
2
// allocate and initialize a const object
const int *pci = new const int(1024);

与其他常量一样,动态创建的 const 对象必须在创建时初始化,并且一经初始化,其值就不能再修改。上述 new 表达式返回指向 int 型 const 对象的指针。与其他 const 对象的地址一样,由于 new 返回的地址上存放的是 const 对象,因此该地址只能赋给指向 const 的指针。

对于类类型的 const 动态对象,如果该类提供了默认的构造函数,则此对象可隐式初始化:

1
2
// allocate default initialized const empty string
const string *pcs = new const string;

new 表达式没有显式初始化 pcs 所指向的对象,而是隐式地将 pcs 所指向的对象初始化为空的 string 对象。内置类型对象或未提供默认构造函数的类类型对象必须显式初始化。

回收

尽管程序员不能改变 const 对象的值,但可撤销对象本身。如同其他动态对象一样, const 动态对象也是使用删除指针来释放的:

1
delete pci; // ok: deletes a const object

即使 delete 表达式的操作数是指向 int 型 const 对象的指针,该语句同样有效地回收 pci 所指向的内容。

警告:动态内存的管理容易出错

下面三种常见的程序错误都与动态内存分配相关:

  1. 删除(delete)指向动态分配内存的指针失败,因而无法将该块内存返还给自由存储区。删除动态分配内存失败称为“内存泄漏(memory leak)”。内存泄漏很难发现,一般需等应用程序运行了一段时间后,耗尽了所有内存空间时,内存泄漏才会显露出来。
  2. 读写已删除的对象。如果删除指针所指向的对象之后,将指针置为 0 值,则比较容易检测出这类错误。
  3. 对同一个内存空间使用两次 delete 表达式。当两个指针指向同一个动态创建的对象,删除时就会发生错误。如果在其中一个指针上做 delete 运算,将该对象的内存空间返还给自由存储区,然后接着 delete 第二个指针,此时则自由存储区可能会被破坏。

动态数组

数组类型的变量有三个重要的限制:数组长度固定不变,在编译时必须知道其长度,数组只在定义它的块语句内存在。实际的程序往往不能忍受这样的限制——它们需要在运行时动态地分配数组。虽然数组长度是固定的,但 动态分配的数组不必在编译时知道其长度,可以(通常也是)在运行时才确定数组长度 。与数组变量不同,动态分配的数组将一直存在,直到程序显式释放它为止。

定义

动态分配数组时,只需指定 类型数组长度 ,不必为数组对象命名,new 表达式返回指向新分配数组的第一个元素的指针:

1
int *pia = new int[10]; // array of 10 uninitialized ints

此 new 表达式分配了一个含有 10 个 int 型元素的数组,并返回指向该数组第一个元素的指针,此返回值初始化了指针 pia。

new 表达式需要指定指针类型以及在方括号中给出的数组维数,该维数可以是任意的复杂表达式。创建数组后,new 将返回指向数组第一个元素的指针。在自由存储区中创建的数组对象是没有名字的,程序员只能通过其地址间接地访问堆中的对象。

初始化

默认初始化

动态分配数组时,如果数组元素具有类类型,将使用该类的默认构造函数实现初始化;如果数组元素是内置类型,则无初始化:

1
2
string *psa = new string[10]; // array of 10 empty strings
int *pia = new int[10]; // array of 10 uninitialized ints

这两个 new 表达式都分配了含有 10 个对象的数组。其中第一个数组是 string 类型,分配了保存对象的内存空间后,将调用 string 类型的默认构造函数依次初始化数组中的每个元素。第二个数组则具有内置类型的元素,分配了存储 10 个 int 对象的内存空间,但这些元素没有初始化。

值初始化

1
int *pia2 = new int[10] (); // array of 10 uninitialized ints

圆括号要求编译器对数组做值初始化,在本例中即把数组元素都设置为 0。

对于动态分配的数组,其元素只能初始化为元素类型的默认值,而不能像数组变量一样,用初始化列表为数组元素提供各不相同的初值。

使用

之所以要动态分配数组,往往是由于编译时并不知道数组的长度。我们可以编写如下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
using namespace std;
int main(void)
{
int i, n;
cout << "Nums to be input: " << endl;
cin >> n;
int *p = new int[n];
cout << "Input nums: " << endl;
for (i = 0; i < n; i++)
cin >> p[i];
cout << "Nums you input: " << endl;
for (i = 0; i < n; i++)
cout << p[i] << " ";
}

计算数组长度,然后创建和处理该数组。

再比如,在程序执行过程中,常常使用 char * 指针指向多个 C 风格字符串,于是必须根据每个字符串的长度实时地动态分配存储空间。采用这种技术要比建立固定大小的数组安全。如果程序员能够准确计算出运行时需要的数组长度,就不必再担心因数组变量具有固定的长度而造成的溢出问题。

假设有以下 C 风格字符串:

1
2
3
4
const char *noerr = "success";
// ...
const char *err189 = "Error: a function declaration must "
"specify a function return type!";

我们想在运行时把这两个字符串中的一个复制给新的字符数组,于是可以用以下程序在运行时计算维数:

1
2
3
4
5
6
7
8
9
10
const char *errorTxt;
if (errorFound)
errorTxt = err189;
else
errorTxt = noerr;
// remember the 1 for the terminating null
int dimension = strlen(errorTxt) + 1;
char *errMsg = new char[dimension];
// copy the text for the error into errMsg
strncpy (errMsg, errorTxt, dimension);

空数组

C++ 虽然不允许定义长度为 0 的数组变量,但明确指出,调用 new 动态创建长度为 0 的数组是合法的:

1
2
char arr[0]; // error: cannot define zero-length array
char *cp = new char[0]; // ok: but cp can't be dereferenced

用 new 动态创建长度为 0 的数组时,new 返回有效的非零指针。该指针与 new 返回的其他指针不同,不能进行解引用操作,因为它毕竟没有指向任何元素。而允许的操作包括:

  1. 比较运算,因此该指针能在循环中使用;
  2. 在该指针上加(减)0;
  3. 减去本身,得 0 值。

在上述例题中,如果 get~size~ 返回 0,则仍然可以成功调用 new,但是 p 并没有指向任何对象,数组是空的。因为 n 为 0,所以 for 循环实际比较的是 p 和 q,而 q 是用 p 初始化的,两者具有相等的值,因此 for 循环条件不成立,循环体一次都没有执行。

释放

动态分配的内存最后必须进行释放,否则,内存最终将会逐渐耗尽。如果不再需要使用动态创建的数组,程序员必须显式地将其占用的存储空间返还给程序的自由存储区。C++ 语言为指针提供 delete [] 表达式释放指针所指向的数组空间:

1
delete [] pia;

该语句回收了 pia 所指向的数组,把相应的内存返还给自由存储区。在关键字 delete 和指针之间的空方括号对是必不可少的:它告诉编译器该指针指向的是自由存储区中的数组,而并非单个对象(详见 《Effective C++》 条款5)。如果遗漏了空方括号对,这是一个编译器无法发现的错误,将导致程序在运行时出错。

理论上,回收数组时缺少空方括号对,至少会导致运行时少释放了内存空间,从而产生内存泄漏(memory leak)。对于某些系统和/或元素类型,有可能会带来更严重的运行时错误。因此,在释放动态数组时千万别忘了方括号对。

const 对象的动态数组

如果我们在自由存储区中创建的数组存储了内置类型的 const 对象,则必须为这个数组提供初始化:因为数组元素都是 const 对象,无法赋值。实现这个要求的唯一方法是对数组做值初始化:

1
2
3
4
// error: uninitialized const array
const int *pci_bad = new const int[100];
// ok: value-initialized const array
const int *pci_ok = new const int[100]();

C++ 允许定义类类型的 const 数组,但该类类型必须提供默认构造函数:

1
2
// ok: array of 100 empty strings
const string *pcs = new const string[100];

在这里,将使用 string 类的默认构造函数初始化数组元素。当然,已创建的常量元素不允许修改——因此这样的数组实际上用处不大。

Comments