创建动态数组

数组类型的变量有三个重要的限制:数组长度固定不变,在编译时必须知道其长度,数组只在定义它的块语句内存在.

实际的程序往往不能忍受这样的限制-------它们需要在运行时 动态地分配数组.虽然数组长度是固定的,但动态分配的数组不必在编译时知道其长度,可以(通常也是)在运行时才确定数组长度.与数组变量不同,动态分配的数组将一直存在,知道程序显式释放它为止.

每一个程序在执行时都占用一款可用的内存空间,用于存放动态分配的对象,此内存空间称为程序的自由存储区(free store)或堆(heap).C语言程序使用一对标准库函数malloc和free在自由存储区中分配存储空间,而C++语言则使用new和delete表达式实现相同的功能.

1.动态数组的定义

数组变量通过指定类型、数组名和维数来定义.而动态分配数组时,只需指定类型和数组长度,不必为数组对象命名,new表达式返回指向新分配数组的第一个元素的指针:

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

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

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

2.初始化动态分配的数组

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

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

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

也可使用跟在数组长度后面的一对空圆括号,对数组元素做值初始化:

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

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

-----------------------------------------------------我是无辜的分割线-----------------------------------------------

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

----------------------------------------------------我依然是无辜的分割线---------------------------------------------

3.const对象的动态数组

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

//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数组,但该类类型必须提供默认构造函数:

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

在这里,将使用string类的默认构造函数初始化数组元素.

当然,已创建的常量元素不允许修改------因此这样的数组实际上用处不大.

4.允许动态分配空数组

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

size_t n=get_size();   //get_size returns number of elements needed
int *p=new int[n];
for(int *q=p;q!=p+n;++q)
/* process the array */;

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

有趣的是,如果get_size返回0会怎么样?答案是:代码仍然正确执行.C++虽然不允许定义长度为0的数组变量,但明确指出,调用new动态创建长度为0的数组是合法的:

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返回的其他指针不同,不能进行解引用操作,因为它毕竟没有指向任何元素.而允许的操作包括:比较运算,因此该指针能在循环中使用;在该指针上加(减)0,或者减去本身值,得0值.

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

5.动态空间的释放

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

delete[] pia;

该语句回收了pia所指向的数组,把相应的内存返还给自由存储区.在关键字delete和指针之间的空方括号对是必不可少的:它告诉编译器该指针指向的是自由存储区中的数组,而并非单个对象.

----------------------------------------------我是郁闷的分割线----------------------------------------------------

小心:如果遗漏了空方括号对,这是一个编译器无法发现的错误,将导致程序在运行时出错.

---------------------------------------------我很郁闷,真的--------------------------------------------------------

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

----------------------------------------------------------我是困倦的分割线-------------------------------------

C风格字符串与C++的标准库类型string的比较:

以下两段程序反映了使用C风格字符串与C++的标准库类型string的不同之处.使用string类型的版本更短、更容易理解,而且出错的可能性更小:

//C-style character string implementation
const char *pc="a very long literal string";
const size_t len=strlen(pc +1);  //space to allocate
//performance test on string allocation and copy
for(size_t ix=0;ix!=1000000;++ix){
 char *pc2=new char[len+1];  //allocate the space
 strcpy(pc2,pc);             //do the copy
 if(strcmp(pc2,pc))         //use the nuw string
  ;  //do nothing
 delete[] pc2;              //free the memory
}

//string implementation
string str("a very long literal string");
//performance test on string allocation and copy
for(int ix=0;ix!=1000000;++ix){
 string str2=str;   //do the copy,automatically allocated
 if(str!=str2)     //use the new string
  ;  //do nothing
}                                  //str2 is automatically freed

---------------------------------------------------我是困倦的分割线------------------------------------------------------------

6.动态数组的使用

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

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

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

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

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);

别忘记标准库函数strlen返回的是字符串的长度,并不包括字符串结束符,在获得的字符串长度上必须加1以便在动态分配时预留结束符的存储空间.

习题4.27   假设有下面的new表达式,请问如何释放pa?

int *pa=new int[10];

delete[] pa;  释放pa所指向的数组空间.

习题4.28   编写程序由从标准输入设备读入的元素数据建立一个int型vector对象,然后动态创建一个与vector对象大小一致的数组,把vector对象的所有元素复制给新数组.

//从标准输入设备读入的元素元素数据建立一个int型vector对象
//然后动态创建一个与该vector对象大小一致的数组,
//把vector对象的所有元素复制给新数组
#include<iostream>
#include<vector>
using namespace std;
int main()
{
 vector<int> ivec;
 int ival;
 //读入元素数据并建立vector
 cout<<"Enter numbers:(Ctrl+Z to end)"<<endl;
 while(cin>>ival)
  ivec.push_back(ival);
 //动态创建数组
 int *pia=new int[ivec.size()];
 //复制元素
 int *tp=pia;
 for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter,++tp)
  *tp=*iter;
 //释放动态数组的内存
 delete[] pia;
 return 0;
}

习题4.29   对本小节第五条框中的两段程序:

a.解释这两个程序实现什么功能?

b.平均来说,使用string类型的程序执行速度要比用C风格字符串的快很多,在我们用了五年的PC机上其平均执行速度分别是:

user 0.47  # string class
user 2.55  # C-style character string

你预计的也一样吗?请说明原因.

a.这两段程序的功能是:执行一个循环次数为1000000的循环,在该循环的循环体中:创建一个新字符串,将一个已存在的字符串复制给新字符串,然后比较两个字符串,最后释放新字符串

b.使用C风格字符串的程序需要自己管理内存的分配和释放,而使用string类型的程序由系统自动进行内存的分配和释放,因此比使用C风格字符串的程序要简短,执行速度也要快一点

习题4.30  编写程序连接两个C风格字符串字面值,把结果存储在一个C风格字符串中.然后再编写程序连接两个string类型字符串,这两个string类型字符串与前面C风格字符串字面值具有相同的内容.

//连接两个C风格字符串字面值.
//把结果存储在一个C风格字符串中
#include<cstring>
int main()
{
 const char *cp1="Mary and Linda";
 const char *cp2="are firends";
 size_t len=strlen(cp1)+strlen(cp2);
 char *result_str=new char[len+1]; //动态分配数组
 strcpy(result_str,cp1);
 strcat(result_str,cp2);
 delete[] result_str;
 return 0;
}

//连接两个string类型字符串
#include<string>
using namespace std;
int main()
{
 const string str1("Mary and Linda");
 const string str2("are friends.");
 string result_str;
 result_str=str1;
 result_str+=str2;
 return 0;
}

string看上去简单多了