C++ Primer 【第四版】第四章 数组和指针

习题4.1

假设get_size是一个没有参数并返回int 值的函数，下列哪些定义是非法的？

为什么？

unsignedbuf_size = 1024

(a)int ia[buf_size];

(b)int ia[get_size()];

(c)int ia[4*7-14];

(d)char st[11] = "fundamental" ;

【解答】

(a)非法，buf_size是一个变量，不能用于定义数组的维数（维长度）。

(b)非法，get_size()是函数调用，不是常量表达式，不能用于定义数组的维数

（维长度）。

(d)非法，存放字符串"fundamental"的数组必须有12个元素，st 只有11 个元

素。

习题4.2

下列数组的值是什么？

stringsa[10];

C++Primer（4版）习题解答

62

intia[10];

intmain(){

stringsa2[10];

intia2[10];

}

【解答】

sa和sa2为元素类型为string 的数组，自动调用string 类的默认构造函数将

各元素初始化为空字符串；ia为在函数体外定义的内置数组，各元素初始化为

0；ia2为在函数体内定义的内置数组，各元素未初始化，其值不确定。

习题4.3

下列哪些定义是错误的？

(a)int ia[7] = {0, 1, 1, 2, 3, 5, 8};

(b)vector<int> ivec = {0, 1, 1, 2, 3, 5, 8};

(c)int ia2[] = ia;

(d)int ia3[] = ivec;

【解答】

(b)错误。vector对象不能用这种方式进行初始化。

(c)错误。不能用一个数组来初始化另一个数组。

(d)错误。不能用vector对象来初始化数组。

习题4.4

如何初始化数组的一部分或全部元素？

【解答】

定义数组时可使用初始化列表（用花括号括住的一组以逗号分隔的元素初

值）来初始化数组的部分或全部元素。如果是初始化全部元素，可以省略定义

数组时方括号中给出的数组维数值。如果指定了数组维数，则初始化列表提供

的元素个数不能超过维数值。如果数组维数大于列出的元素初值个数，则只初

C++Primer（4版）习题解答

63

始化前面的数组元素，剩下的其他元素，若是内置类型则初始化为0，若是类类

型则调用该类的默认构造函数进行初始化。字符数组既可以用一组由花括号括

起来、逗号隔开的字符字面值进行初始化，也可以用一个字符串字面值进行初

始化。

习题4.5

列出使用数组而不是vector的缺点。

【解答】

与vector类型相比，数组具有如下缺点：数组的长度是固定的，而且数组

不提供获取其容量大小的size操作，也不提供自动添加元素的push_back 操作。

因此，程序员无法在程序运行时知道一个给定数组的长度，而且如果需要更改

数组的长度，程序员只能创建一个更大的新数组，然后把原数组的所有元素复

制到新数组的存储空间中去。与使用vector类型的程序相比，使用内置数组的

程序更容易出错且难以调试。

习题4.6

下面的程序段企图将下标值赋给数组的每个元素，其中在下标操作上有一些错

误，请指出这些错误。

constsize_t array_size = 10 ;

intia[array_size];

for(size_t ix = 1; ix <= array_size; ++ix)

ia[ix]= ix ;

【解答】

该程序段的错误是：数组下标使用越界。

根据数组ia的定义，该数组的下标值应该是0~9(即array_size-1)，而不是从

1到array_size，因此其中的for语句出错，可更正如下：

for(size_t ix = 0; ix < array_size; ++ix)

ia[ix]= ix ;

习题4.7

编写必要的代码将一个数组赋给另一个数组，然后把这段代码改用vector实现。

考虑如何将一个vector赋给另一个vector。

C++Primer（4版）习题解答

64

【解答】

将一个数组赋给另一个数组，就是将一个数组的元素逐个赋值给另一数组的对

应元素，可用如下代码实现：

intmain()

{

constsize_t array_size = 10;

intia1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

intia2[array_size];

for(size_t ix = 0; ix != array_size; ++ix)

ia2[ix]= ia1[ix];

return0;

}

将一个vector赋给另一个vector，也是将一个vector 的元素逐个赋值给另

一vector的对应元素，可用如下代码实现：

//将一个vector赋值给另一vector

//使用迭代器访问vector中的元素

#include<vector>

usingnamespace std;

intmain()

{

vector<int>ivec1(10, 20);//每个元素初始化为20

vector<int>ivec2;

for(vector<int>::iterator iter = ivec1.begin();

iter!= ivec1.end(); ++iter)

C++Primer（4版）习题解答

65

ivec2.push_back(*iter);

return0;

}

习题4.8

编写程序判断两个数组是否相等，然后编写一段类似的程序比较两个vector。

【解答】

判断两个数组是否相等，可用如下程序：

//判断两个数组是否相等

#include<iostream>

usingnamespace std;

intmain()

{

constint arr_size = 6;

intia1[arr_size], ia2[arr_size];

size_tix;

//读入两个数组的元素值

cout<< "Enter " << arr_size

<<" numbers for array1:" << endl;

for(ix = 0; ix != arr_size; ++ix)

cin>> ia1[ix];

cout<< "Enter " << arr_size

<<" numbers for array2:" << endl;

for(ix = 0; ix != arr_size; ++ix)

cin>> ia2[ix];

C++Primer（4版）习题解答

66

//判断两个数组是否相等

for(ix = 0; ix != arr_size; ++ix)

if(ia1[ix] != ia2[ix]) {

cout<< "Array1 is not equal to array2." << endl;

return0;

}

cout<< "Array1 is equal to array2." << endl;

return0;

}

判断两个vector是否相等，可用如下程序：

//判断两个vector是否相等

//使用迭代器访问vector中的元素

#include<iostream>

#include<vector>

usingnamespace std;

intmain()

{

vector<int>ivec1, ivec2;

intival;

//读入两个vector的元素值

cout<< "Enter numbers for vector1(-1 to end):" << endl;

cin>> ival;

while(ival != -1) {

ivec1.push_back(ival);

C++Primer（4版）习题解答

67

cin>> ival;

}

cout<< "Enter numbers for vector2(-1 to end):" << endl;

cin>> ival;

while(ival != -1) {

ivec2.push_back(ival);

cin>> ival;

}

//判断两个vector是否相等

if(ivec1.size() != ivec2.size()) //长度不等的vector不相等

cout<< "Vector1 is not equal to vector2." << endl;

elseif (ivec1.size() == 0) //长度都为0的vector 相等

cout<< "Vector1 is equal to vector2." << endl;

else{//两个vector长度相等且不为0

vector<int>::iteratoriter1, iter2;

iter1= ivec1.begin();

iter2= ivec2.begin();

while(*iter1 == *iter2 && iter1 != ivec1.end()

&&iter2 != ivec2.end()) {

++iter1;

++iter2;

}

if(iter1 == ivec1.end())//所有元素都相等

cout<< "Vector1 is equal to vector2." << endl;

C++Primer（4版）习题解答

68

else

cout<< "Vector1 is not equal to vector2." << endl;

}

return0;

}

习题4.9

编写程序定义一个有10个int 型元素的数组，并以元素在数组中的位置作为各

元素的初值。

【解答】

//定义一个有10个int型元素的数组，

//并以元素在数组中的位置（1~10）作为各元素的初值

intmain()

{

constint array_size = 10;

intia[array_size];

for(size_t ix = 0; ix != array_size; ++ix)

ia[ix]= ix+1;

return0;

}

习题4.10

下面提供了两种指针声明的形式，解释宁愿使用第一种形式的原因：

int*ip; // good practice

int*ip; // legal but misleading

C++Primer（4版）习题解答

69

【解答】

第一种形式强调了ip是一个指针，这种形式在阅读时不易引起误解，尤其

是当一个语句中同时定义了多个变量时。

习题4.11

解释下列声明语句，并指出哪些是非法的，为什么？

(a)int* ip;

(b)string s, *sp = 0;

(c)int i; double* dp = &i;

(d)int* ip, ip2;

(e)const int i = 0, *p = i;

(f)string *p = NULL;

【解答】

(a)合法。定义了一个指向int型对象的指针ip。

(b)合法。定义了string对象s和指向string 型对象的指针sp，sp初始化为0

值。

(c)非法。dp为指向double 型对象的指针，不能用int 型对象i 的地址进行初

始化。

(d)合法。定义了int对象ip2和指向int 型对象的指针ip。

(e)合法。定义了constint型对象i 和指向const int 型对象的指针p，i初

始化为0，p初始化为0。

(f)合法。定义了指向string型对象的指针p，并将其初始化为0 值。

习题4.12

已知一指针p，你可以确定该指针是否指向一个有效的对象吗？如果可以，如何

确定？如果不可以，请说明原因。

【解答】

C++Primer（4版）习题解答

70

无法确定某指针是否指向一个有效对象。因为，在C++语言中，无法检测指

针是否未被初始化，也无法区分一个地址是有效地址，还是由指针所分配的存

储空间中存放的不确定值的二进制位形成的地址。

习题4.13

下列代码中，为什么第一个指针的初始化是合法的，而第二个则不合法？

inti = 42;

void*p = &i;

long*lp = &i;

【解答】

具有void*类型的指针可以保存任意类型对象的地址，因此p的初始化是合

法的；而指向long型对象的指针不能用int 型对象的地址来初始化，因此lp

的初始化不合法。

习题4.14

编写代码修改指针的值；然后再编写代码修改指针所指对象的值。

【解答】

下列代码修改指针的值：

int*ip;

intival1, ival2;

ip= &ival1;

ip= &ival2;

下列代码修改指针所指对象的值：

intival = 0;

int*ip = &ival;

*ip= 8;

习题4.15

C++Primer（4版）习题解答

71

解释指针和引用的主要区别。

【解答】

使用引用（reference）和指针（pointer）都可间接访问另一个值，但它们之

间存在两个重要区别：(1)引用总是指向某个确定对象（事实上，引用就是该对

象的别名），定义引用时没有进行初始化会出现编译错误；(2)赋值行为上存

在差异：给引用赋值修改的是该引用所关联的对象的值，而不是使该引用与另

一个对象关联。引用一经初始化，就始终指向同一个特定对象。给指针赋值修

改的是指针对象本身，也就是使该指针指向另一对象，指针在不同时刻可指向

不同的对象（只要保证类型匹配）。

习题4.16

下列程序段实现什么功能？

inti = 42, j = 1024;

int*p1 = &i, *p2 = &j;

*p2= *p1 * * p2;

*p1*= *p1;

【解答】

该程序段使得i被赋值为42 的平方，j 被赋值为42与1024 的乘积。

习题4.17

已知p1和p2 指向同一个数组中的元素，下面语句实现什么功能？

p1+= p2 – p1;

当p1和p2 具有什么值时这个语句是非法的？

【解答】

此语句使得p1也指向p2 原来所指向的元素。原则上说，只要p1 和p2 的类型

相同，则该语句始终是合法的。只有当p1和p2 不是同类型指针时，该语句才

不合法（不能进行-操作）。

但是，如果p1和p2 不是指向同一个数组中的元素，则这个语句的执行结果可

能是错误的。因为-操作的结果类型ptrdiff_t只能保证足以存放同一数组中两

个指针之间的差距。如果p1和p2 不是指向同一个数组中的元素，则-操作的结

C++Primer（4版）习题解答

72

果有可能超出ptrdiff_t类型的表示范围而产生溢出，从而该语句的执行结果

不能保证p1指向p2 原来所指向的元素（甚至不能保证p1 为有效指针）。

习题4.18

编写程序，使用指针把一个int型数组的所有元素设置为0。

【解答】

//使用指针把一个int型数组的所有元素设置为0

intmain()

{

constsize_t arr_size = 8;

intint_arr[arr_size] = { 0, 1, 2, 3, 4, 5, 6, 7 };

//pbegin指向第一个元素，pend指向最后一个元素的下一内存位置

for(int *pbegin = int_arr, *pend = int_arr + arr_size;

pbegin!= pend; ++pbegin)

*pbegin= 0; //当前元素置0

return0;

}

习题4.19

解释下列5个定义的含义，指出其中哪些定义是非法的：

(a)int i;

(b)const int ic;

(c)const int *pic;

(d)int *const cpi;

(e)const int *const cpic;

【解答】

C++Primer（4版）习题解答

73

(a)合法：定义了int型对象i。

(b)非法：定义const对象时必须进行初始化，但ic 没有初始化。

(c)合法：定义了指向int型const 对象的指针pic。

(d)非法：因为cpi被定义为指向int 型对象的const指针，但该指针没有初

始化。

(e)非法：因为cpic被定义为指向int 型const对象的const指针，但该指针

没有初始化。

习题4.20

下列哪些初始化是合法的？为什么？

(a)int i = -1;

(b)const int ic = i ;

(c)const int *pic = &ic;

(d)int *const cpi = &ic;

(e)const int *const cpic = &ic;

【解答】

(a)合法：定义了一个int型对象i，并用int 型字面值-1对其进行初始化。

(b)合法：定义了一个int型const 对象ic，并用int型对象对其进行初始

化。

(c)合法：定义了一个指向int型const 对象的指针pic，并用ic的地址对

其进行初始化。

(d)不合法：cpi是一个指向int 型对象的const指针，不能用const int

型对象ic的地址对其进行初始化。

(e)合法：定义了一个指向int型const 对象的const 指针cpic，并用ic

的地址对其进行初始化。

习题4.21

根据上述定义，下列哪些赋值运算是合法的？为什么？

C++Primer（4版）习题解答

74

(a)i = ic; (b) pic = &ic;

(c)cpi = pic; (d) pic = cpic;

(e)cpic = &ic; (f) ic = *cpic;

【解答】

(a)、(b)、(d)合法。

(c)、(e)、(f)均不合法，因为cpi、cpic和ic 都是const 变量（常量），常

量不能被赋值。

习题4.22

解释下列两个while循环的差别：

constchar *cp = "hello";

intcnt;

while(cp) { ++cnt; ++cp; }

while(*cp) { ++cnt; ++cp; }

【解答】

两个while循环的差别为：前者的循环结束条件是cp 为0 值（即指针cp 为0

值）；后者的循环结束条件是cp所指向的字符为0 值（即cp 所指向的字符为

字符串结束符null（即'\0'））。因此后者能正确地计算出字符串"hello"中有

效字符的数目（放在cnt中），而前者的执行是不确定的。

注意，题目中的代码还有一个小问题，即cnt没有初始化为0 值。

习题4.23

下列程序实现什么功能？

constchar ca[] = {'h', 'e', 'l', 'l', 'o'};

constchar *cp = ca ;

while(*cp) {

cout<< *cp << endl;

C++Primer（4版）习题解答

75

++cp;

}

【解答】

该程序段从数组ca的起始地址（即字符'h'的存储地址）开始，输出一段内

存中存放的字符，每行输出一个字符，直至存放0值（null）的字节为止。（注

意，输出的内容一般来说要多于5个字符，因为字符数组ca 中没有null结束

符。）

习题4.24

解释strcpy和strncpy 的差别在哪里，各自的优缺点是什么？

【解答】

strcpy和strncpy的差别在于：前者复制整个指定的字符串，后者只复制指定

字符串中指定数目的字符。

strcpy比较简单，而使用strncpy可以适当地控制复制字符的数目，因此比

strcpy更为安全。

习题4.25

编写程序比较两个string类型的字符串，然后编写另一个程序比较两个C 风格

字符串的值。

【解答】

比较两个string类型的字符串的程序如下：

//比较两个string类型的字符串

#include<iostream>

#include<string>

usingnamespace std;

intmain()

{

stringstr1, str2;

C++Primer（4版）习题解答

76

//输入两个字符串

cout<< "Enter two strings:" << endl;

cin>> str1 >> str2;

//比较两个字符串

if(str1 > str2)

cout<< "\"" << str1 << "\""<< " is bigger than "

<<"\"" << str2 << "\"" << endl;

elseif (str1 < str2)

cout<< "\"" << str2 << "\""<< " is bigger than "

<<"\"" << str1 << "\"" << endl;

else

cout<< "They are equal" << endl;

return0;

}

比较两个C风格字符串的程序如下：

//比较两个C风格字符串的值

#include<iostream>

#include<cstring>

usingnamespace std;

intmain()

{

//char*str1 = "string1", *str2 = "string2";

constint str_size = 80;

char*str1, *str2;

C++Primer（4版）习题解答

77

//为两个字符串分配内存

str1= new char[str_size];

str2= new char[str_size];

if(str1 == NULL || str2 == NULL) {

cout<< "No enough memory!" << endl;

return-1;

}

//输入两个字符串

cout<< "Enter two strings:" << endl;

cin>> str1 >> str2;

//比较两个字符串

intresult;

result= strcmp(str1, str2);

if(result > 0)

cout<< "\"" << str1 << "\""<< " is bigger than "

<<"\"" << str2 << "\"" << endl;

elseif (result < 0)

cout<< "\"" << str2 << "\""<< " is bigger than "

<<"\"" << str1 << "\"" << endl;

else

cout<< "They are equal" << endl;

//释放字符串所占用的内存

delete[] str1 ;

delete[] str2 ;

C++Primer（4版）习题解答

78

return0;

}

注意，此程序中使用了内存的动态分配与释放（见4.3.1节）。如果不用内存

的动态分配与释放，可将主函数中第2、3两行代码、有关内存分配与释放的代

码以及输入字符串的代码注释掉，再将主函数中第一行代码

//char*str1 = "string1", *str2 = "string2";

前的双斜线去掉即可。

习题4.26

编写程序从标准输入设备读入一个string类型的字符串。考虑如何编程实现从

标准输入设备读入一个C风格字符串。

【解答】

从标准输入设备读入一个string类型字符串的程序段：

stringstr;

cin>> str;

从标准输入设备读入一个C风格字符串可如下实现：

constint str_size = 80;

charstr[str_size];

cin>> str;

习题4.27

假设有下面的new表达式，请问如何释放pa？

int*pa = new int[10];

【解答】

用语句delete [] pa;释放pa所指向的数组空间。

习题4.28

C++Primer（4版）习题解答

79

编写程序由从标准输入设备读入的元素数据建立一个int型vector 对象，然后

动态创建一个与该vector对象大小一致的数组，把vector 对象的所有元素复

制给新数组。

【解答】

//从标准输入设备读入的元素数据建立一个int型vector 对象，

//然后动态创建一个与该vector对象大小一致的数组，

//把vector对象的所有元素复制给新数组

#include<iostream>

#include<vector>

usingnamespace std;

intmain()

{

vector<int>ivec;

intival;

//读入元素数据并建立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)

C++Primer（4版）习题解答

80

*tp= *iter;

//释放动态数组的内存

delete[] pia;

return0;

}

习题4.29

对本节第5条框中的两段程序：

(a)解释这两段程序实现的功能。

(b)平均来说，使用string类型的程序执行速度要比用C 风格字符串的快很多，

在我们用了5年的PC 机上其平均执行速度分别是：

user0.47 # string class

user2.55 # C-style character string

你预计的也一样吗？请说明原因。

【解答】

(a)这两段程序的功能是：执行一个循环次数为1000000的循环，在该循环的

循环体中：创建一个新字符串，将一个已存在的字符串复制给新字符串，然后

比较两个字符串，最后释放新字符串。

(b)使用C风格字符串的程序需要自己管理内存的分配和释放，而使用string

类型的程序由系统自动进行内存的分配和释放，因此比使用C风格字符串的程

序要简短，执行速度也要快一些。

习题4.30

编写程序连接两个C风格字符串字面值，把结果存储在一个C 风格字符串中。

然后再编写程序连接两个string类型字符串，这两个string 类型字符串与前

面的C风格字符串字面值具有相同的内容。

【解答】

连接两个C风格字符串字面值的程序如下：

//连接两个C风格字符串字面值，

C++Primer（4版）习题解答

81

//把结果存储在一个C风格字符串中

#include<cstring>

intmain()

{

constchar *cp1 = "Mary and Linda ";

constchar *cp2 = "are firends.";

size_tlen = strlen(cp1) + strlen(cp2);

char*result_str = new char[len+1];

strcpy(result_str,cp1);

strcat(result_str,cp2);

delete[] result_str;

return0;

}

相应的连接两个string类型字符串的程序如下：

//连接两个string类型字符串

#include<string>

usingnamespace std;

intmain()

{

conststring str1("Mary and Linda ");

conststring str2("are firends.");

stringresult_str;

result_str= str1;

result_str+= str2;

C++Primer（4版）习题解答

82

return0;

}

习题4.31

编写程序从标准输入设备读入字符串，并把该串存放在字符数组中。描述你的

程序如何处理可变长的输入。提供比你分配的数组长度长的字符串数据测试你

的程序。

【解答】

//从标准输入设备读入字符串，并把该串存放在字符数组中

#include<iostream>

#include<string>

#include<cstring>

usingnamespace std;

intmain()

{

stringin_str;//用于读入字符串的string对象

constsize_t str_size = 10;

charresult_str[str_size+1];

//读入字符串

cout<< "Enter a string(<=" << str_size

<<" characters):" << endl;

cin>> in_str;

//计算需复制的字符的数目

size_tlen = strlen(in_str.c_str());

if(len > str_size) {

C++Primer（4版）习题解答

83

len= str_size;

cout<< "String is longer than " << str_size

<<" characters and is stored only "

<<str_size << " characters!" << endl;

}

//复制len个字符至字符数组result_str

strncpy(result_str,in_str.c_str(), len);

//在末尾加上一个空字符（null字符）

result_str[len+1]= '\0';

return0;

}

为了接受可变长的输入，程序中用一个string对象存放读入的字符串，然后使

用strncpy函数将该对象的适当内容复制到字符数组中。因为字符数组的长度

是固定的，因此首先计算字符串的长度。若该长度小于或等于字符数组可容纳

字符串的长度，则复制整个字符串至字符数组，否则，根据数组的长度，复制

字符串中前面部分的字符，以防止溢出。

注意，上述给出的是满足题目要求的一个解答，事实上，如果希望接受可变长

的输入并完整地存放到字符数组中，可以采用动态创建数组来实现。

习题4.32

编写程序用int型数组初始化vector 对象。

【解答】

//用int型数组初始化vector 对象

#include<iostream>

#include<vector>

usingnamespace std;

intmain()

C++Primer（4版）习题解答

84

{

constsize_t arr_size = 8;

intint_arr[arr_size];

//输入数组元素

cout<< "Enter " << arr_size << " numbers:"<< endl;

for(size_t ix = 0; ix != arr_size; ++ix)

cin>> int_arr[ix];

//用int型数组初始化vector 对象

vector<int>ivec(int_arr, int_arr + arr_size);

return0;

}

习题4.33

编写程序把int型vector 复制给int 型数组。

【解答】

//把int型vector 复制给int 型数组

#include<iostream>

#include<vector>

usingnamespace std;

intmain()

{

vector<int>ivec;

intival;

//输入vector元素

cout<< "Enter numbers: (Ctrl+Z to end)" << endl;

C++Primer（4版）习题解答

85

while(cin >> ival)

ivec.push_back(ival);

//创建数组

int*parr = new int[ivec.size()];

//复制元素

size_tix = 0;

for(vector<int>::iterator iter = ivec.begin();

iter!= ivec.end(); ++iter, ++ix)

parr[ix]= *iter;

//释放数组

delete[] parr;

return0;

}

习题4.34

编写程序读入一组string类型的数据，并将它们存储在vector 中。接着，把

该vector对象复制给一个字符指针数组。为vector 中的每个元素创建一个新

的字符数组，并把该vector元素的数据复制到相应的字符数组中，最后把指向

该数组的指针插入字符指针数组。

【解答】

//4-34.cpp

//读入一组string类型的数据，并将它们存储在vector中。

//接着，把该vector对象复制给一个字符指针数组。

//为vector中的每个元素创建一个新的字符数组，

//并把该vector元素的数据复制到相应的字符数组中，

//最后把指向该数组的指针插入字符指针数组

C++Primer（4版）习题解答

86

#include<iostream>

#include<vector>

#include<string>

usingnamespace std;

intmain()

{

vector<string>svec;

stringstr;

//输入vector元素

cout<< "Enter strings:(Ctrl+Z to end)" << endl;

while(cin >> str)

svec.push_back(str);

//创建字符指针数组

char**parr = new char*[svec.size()];

//处理vector元素

size_tix = 0;

for(vector<string>::iterator iter = svec.begin();

iter!= svec.end(); ++iter, ++ix) {

//创建字符数组

char*p = new char[(*iter).size()+1];

//复制vector元素的数据到字符数组

strcpy(p,(*iter).c_str());

//将指向该字符数组的指针插入到字符指针数组

C++Primer（4版）习题解答

87

parr[ix]= p;

}

//释放各个字符数组

for(ix =0; ix != svec.size(); ++ix)

delete[] parr[ix];

//释放字符指针数组

delete[] parr;

return0;

}

习题4.35

输出习题4.34中建立的vector 对象和数组的内容。输出数组后，记得释放字

符数组。

【解答】

//4-35.cpp

//读入一组string类型的数据，并将它们存储在vector中。

//接着，把该vector对象复制给一个字符指针数组:

//为vector中的每个元素创建一个新的字符数组，

//并把该vector元素的数据复制到相应的字符数组中，

//然后把指向该数组的指针插入字符指针数组。

//输出建立的vector对象和数组的内容

#include<iostream>

#include<vector>

#include<string>

usingnamespace std;

C++Primer（4版）习题解答

88

intmain()

{

vector<string>svec;

stringstr;

//输入vector元素

cout<< "Enter strings:(Ctrl+Z to end)" << endl;

while(cin >> str)

svec.push_back(str);

//创建字符指针数组

char**parr = new char*[svec.size()];

//处理vector元素

size_tix = 0;

for(vector<string>::iterator iter = svec.begin();

iter!= svec.end(); ++iter, ++ix) {

//创建字符数组

char*p = new char[(*iter).size()+1];

//复制vector元素的数据到字符数组

strcpy(p,(*iter).c_str());

//将指向该字符数组的指针插入到字符指针数组

parr[ix]= p;

}

//输出vector对象的内容

cout<< "Content of vector:" << endl;

for(vector<string>::iterator iter2 = svec.begin();

C++Primer（4版）习题解答

89

iter2!= svec.end(); ++iter2)

cout<< *iter2 << endl;

//输出字符数组的内容

cout<< "Content of character arrays:" << endl;

for(ix =0; ix != svec.size(); ++ix)

cout<< parr[ix] << endl;

//释放各个字符数组

for(ix =0; ix != svec.size(); ++ix)

delete[] parr[ix];

//释放字符指针数组

delete[] parr;

return0;

}

习题4.36

重写程序输出ia数组的内容，要求在外层循环中不能使用typedef 定义的类型。

【解答】

//4-36.cpp

//重写程序输出ia数组的内容

//在外层循环中不使用typedef定义的类型

#include<iostream>

usingnamespace std;

intmain()

{

C++Primer（4版）习题解答

90

intia[3][4] = { // 3个元素，每个元素是一个有4个int 元素的数

组

{0,1, 2, 3} , // 0行的初始化列表

{4,5, 6, 7} , // 1行的初始化列表

{8,9, 10, 11} // 2行的初始化列表

};

int(*p)[4];

for(p = ia; p != ia + 3; ++p)

for(int *q = *p; q != *p + 4; ++q)

cout<< *q << endl;

return0;

}