第四版课后习题答案 第06章 数组指针与字符串.docx

第四版课后习题答案 第06章 数组指针与字符串.docx

《第四版课后习题答案 第06章 数组指针与字符串.docx》由会员分享，可在线阅读，更多相关《第四版课后习题答案 第06章 数组指针与字符串.docx（24页珍藏版）》请在冰点文库上搜索。

第四版课后习题答案第06章数组指针与字符串

第六章数组、指针与字符串

6-1数组A[10][5][15]一共有多少个元素？

解：

10×5×15=750个元素

6-2在数组A[20]中第一个元素和最后一个元素是哪一个？

解：

第一个元素是A[0]，最后一个元素是A[19]。

6-3用一条语句定义一个有五个元素的整型数组，并依次赋予1~5的初值。

解：

源程序：

intIntegerArray[5]={1，2，3，4，5};

或：

intIntegerArray[]={1，2，3，4，5};

6-4已知有一个数组名叫oneArray，用一条语句求出其元素的个数。

解：

源程序：

nArrayLength=sizeof（oneArray）/sizeof（oneArray[0]）;

6-5用一条语句定义一个有5×3个元素的二维整型数组，并依次赋予1~15的初值。

解：

源程序：

inttheArray[5][3]={1，2，3，4，5，6，7，8，9，10，11，12，13，14，15};

或：

inttheArray[5][3]={{1，2，3}，{4，5，6}，{7，8，9}，{10，11，12}，{13，14，15}};

6-6运算符*和&的作用是什么？

解：

*称为指针运算符，是一个一元操作符，表示指针所指向的对象的值；&称为取地址运算符，也是一个一元操作符，是用来得到一个对象的地址。

6-7什么叫做指针？

指针中储存的地址和这个地址中的值有何区别？

解：

指针是一种数据类型，具有指针类型的变量称为指针变量。

指针变量存放的是另外一个对象的地址，这个地址中的值就是另一个对象的内容。

6-8声明一个整型指针，用new语句为其分配包含10个整型元素的地址空间。

解：

源程序：

int*pInteger=newint[10];

6-9在字符串”Hello，world!

”中结束符是什么？

解：

是NULL字符。

6-10定义一个有五个元素的整型数组，在程序中提示用户输入元素值，最后再在屏幕上显示出来。

解：

源程序：

#include

intmain（）

{

intmyArray[5];

inti;

for（i=0;i<5;i++）

{

cout<<"ValueformyArray["<

";

cin>>myArray[i];

}

for（i=0;i<5;i++）

cout<

"<

return0;

}

程序运行输出：

ValueformyArray[0]:

2

ValueformyArray[1]:

5

ValueformyArray[2]:

7

ValueformyArray[3]:

8

ValueformyArray[4]:

3

0:

2

1:

5

2:

7

3:

8

4:

3

6-11引用和指针有何区别？

何时只能使用指针而不能使用引用？

解：

引用是一个别名，不能为NULL值，不能被重新分配；指针是一个存放地址的变量。

当需要对变量重新赋以另外的地址或赋值为NULL时只能使用指针。

6-12声明下列指针：

float类型变量的指针pFloat，char类型的指针pString和structcustomer型的指针prec。

解：

float*pfloat;

char*pString;

structcustomer*prec;

6-13给定float类型的指针fp，写出显示fp所指向的值的输出流语句。

解：

cout<<"Value=="<<*fp;

6-14程序中定义一个double类型变量的指针。

分别显示指针占了多少字节和指针所指的变量占了多少字节。

解：

double*counter;

cout<<"\nSizeofpointer=="sizeof（counter）;

cout<<'\nSizeofaddressedvalue=="<

6-15constint*p1和int*constp2的区别是什么？

解：

constint*p1声明了一个指向整型常量的指针p1，因此不能通过指针p1来改变它所指向的整型值；int*const

p2声明了一个指针型常量，用于存放整型变量的地址，这个指针一旦初始化后，就不能被重新赋值了。

6-16定义一个整型变量a，一个整型指针p，一个引用r，通过p把a的值改为10，通过r把a的值改为5

解：

voidmain（）

{

inta;

int*p=&a;

int&r=a;

*p=10;

r=5;

}

6-17下列程序有何问题，请仔细体会使用指针时应避免出现这个的问题。

#include

intmain（）

{

int*p;

*pInt=9;

cout<<"Thevalueatp:

"<<*p;

return0;

}

解：

指针p没有初始化，也就是没有指向某个确定的内存单元，它指向内存中的一个随机地址，给这个随机地址赋值是非常危险的。

6-18下列程序有何问题，请改正；仔细体会使用指针时应避免出现的这个问题。

#include

intFn1（）;

intmain（）

{

inta=Fn1（）;

cout<<"thevalueofais:

"<

return0;

}

intFn1（）

{

int*p=newint（5）;

return*p;

}

解：

此程序中给*p分配的内存没有被释放掉。

改正：

#include

int*Fn1（）;

intmain（）

{

int*a=Fn1（）;

cout<<"thevalueofais:

"<<*a;

deletea;

return0;

}

int*Fn1（）

{

int*p=newint（5）;

returnp;

}

6-19声明一个参数为整型，返回值为长整型的函数指针；声明类A的一个成员函数指针，其参数为整型，返回值长整型。

解：

long（*p_fn1）（int）;

long（A:

:

*p_fn2）（int）;

6-20实现一个名为SimpleCircle的简单圆类，其数据成员int*itsRadius为一个指向其半径值的指针，设计对数据成员的各种操作，给出这个类的完整实现并测试这个类。

解：

源程序：

#include

classSimpleCircle

{

public:

SimpleCircle（）;

SimpleCircle（int）;

SimpleCircle（constSimpleCircle&）;

~SimpleCircle（）{}

voidSetRadius（int）;

intGetRadius（）const;

private:

int*itsRadius;

};

SimpleCircle:

:

SimpleCircle（）

{

itsRadius=newint（5）;

}

SimpleCircle:

:

SimpleCircle（intradius）

{

itsRadius=newint（radius）;

}

SimpleCircle:

:

SimpleCircle（constSimpleCircle&rhs）

{

intval=rhs.GetRadius（）;

itsRadius=newint（val）;

}

intSimpleCircle:

:

GetRadius（）const

{

return*itsRadius;

}

intmain（）

{

SimpleCircleCircleOne,CircleTwo（9）;

cout<<"CircleOne:

"<

cout<<"CircleTwo:

"<

return0;

}程序运行输出：

CircleOne:

5

CircleTwo:

9

6-21编写一个函数，统计一个英文句子中字母的个数，在主程序中实现输入、输出。

解：

源程序：

#include

#include

intcount（char*str）

{

inti,num=0;

for（i=0;str[i];i++）

{

if（（str[i]>='a'&&str[i]<='z'）||（str[i]>='A'&&str[i]<='Z'））

num++;

}

returnnum;

}

voidmain（）

{

chartext[100];

cout<<"输入一个英语句子：

"<

gets（text）;

cout<<"这个句子里有"<

"<

}

程序运行输出：

输入一个英语句子：

Itisveryinteresting!

这个句子里有19个字母。

6-22编写函数reverse（char*s）的倒序递归程序，使字符串s倒序。

解：

源程序：

#include

#include

voidreverse（char*s,char*t）

{

charc;

if（s

{

c=*s;

*s=*t;

*t=c;

reverse（++s,--t）;

}

}

voidreverse（char*s）

{

reverse（s,s+strlen（s）-1）;

}

voidmain（）

{

charstr1[20];

cout<<"输入一个字符串：

";

cin>>str1;

cout<<"原字符串为：

"<

reverse（str1）;

cout<<"倒序反转后为：

"<

}

程序运行输出：

输入一个字符串：

abcdefghijk

原字符串为：

abcdefghijk

倒序反转后为：

kjihgfedcba

6-23设学生人数N=8，提示用户输入N个人的考试成绩，然后计算出平均成绩，显示出来。

解：

源程序：

#include

#include

#defineN8

floatgrades[N];//存放成绩的数组

voidmain（）

{

inti;

floattotal,average;

//提示输入成绩

for（i=0;i

{

cout<<"Entergrade#"<<（i+1）<<":

";

cin>>grades[i];

}

total=0;

for（i=0;i

total+=grades[i];

average=total/N;

cout<<"\nAveragegrade:

"<

}

程序运行输出：

Entergrade#1:

86

Entergrade#2:

98

Entergrade#3:

67

Entergrade#4:

80

Entergrade#5:

78

Entergrade#6:

95

Entergrade#7:

78

Entergrade#8:

56

Averagegrade:

79.75

6-24

设计一个字符串类MyString，具有构造函数、析构函数、拷贝构造函数，重载运算符+、=、+=、[]，尽可能地完善它，使之能满足各种需要。

（运算符重载功能为选做，参见第8章）

解：

#include

#include

classMyString

{

public:

MyString（）;

MyString（constchar*const）;

MyString（constMyString&）;

~MyString（）;

char&operator[]（unsignedshortoffset）;

charoperator[]（unsignedshortoffset）const;

MyStringoperator+（constMyString&）;

voidoperator+=（constMyString&）;

MyString&operator=（constMyString&）;

unsignedshortGetLen（）const{returnitsLen;}

constchar*GetMyString（）const{returnitsMyString;}

private:

MyString（unsignedshort）;//privateconstructor

char*itsMyString;

unsignedshortitsLen;

};

MyString:

:

MyString（）

{

itsMyString=newchar[1];

itsMyString[0]='\0';

itsLen=0;

}

MyString:

:

MyString（unsignedshortlen）

{

itsMyString=newchar[len+1];

for（unsignedshorti=0;i<=len;i++）

itsMyString[i]='\0';

itsLen=len;

}

MyString:

:

MyString（constchar*constcMyString）

{

itsLen=strlen（cMyString）;

itsMyString=newchar[itsLen+1];

for（unsignedshorti=0;i

itsMyString[i]=cMyString[i];

itsMyString[itsLen]='\0';

}

MyString:

:

MyString（constMyString&rhs）

{

itsLen=rhs.GetLen（）;

itsMyString=newchar[itsLen+1];

for（unsignedshorti=0;i

itsMyString[i]=rhs[i];

itsMyString[itsLen]='\0';

}

MyString:

:

~MyString（）

{

delete[]itsMyString;

itsLen=0;

}

MyString&MyString:

:

operator=（constMyString&rhs）

{

if（this==&rhs）

return*this;

delete[]itsMyString;

itsLen=rhs.GetLen（）;

itsMyString=newchar[itsLen+1];

for（unsignedshorti=0;i

itsMyString[i]=rhs[i];

itsMyString[itsLen]='\0';

return*this;

}

char&MyString:

:

operator[]（unsignedshortoffset）

{

if（offset>itsLen）

returnitsMyString[itsLen-1];

else

returnitsMyString[offset];

}

charMyString:

:

operator[]（unsignedshortoffset）const

{

if（offset>itsLen）

returnitsMyString[itsLen-1];

else

returnitsMyString[offset];

}

MyStringMyString:

:

operator+（constMyString&rhs）

{

unsignedshorttotalLen=itsLen+rhs.GetLen（）;

MyStringtemp（totalLen）;

for（unsignedshorti=0;i

temp[i]=itsMyString[i];

for（unsignedshortj=0;j

temp[i]=rhs[j];

temp[totalLen]='\0';

returntemp;

}

voidMyString:

:

operator+=（constMyString&rhs）

{

unsignedshortrhsLen=rhs.GetLen（）;

unsignedshorttotalLen=itsLen+rhsLen;

MyStringtemp（totalLen）;

for（unsignedshorti=0;i

temp[i]=itsMyString[i];

for（unsignedshortj=0;j

temp[i]=rhs[i-itsLen];

temp[totalLen]='\0';

*this=temp;

}

intmain（）

{

MyStrings1（"initialtest"）;

cout<<"S1:

\t"<

char*temp="HelloWorld";

s1=temp;

cout<<"S1:

\t"<

chartempTwo[20];

strcpy（tempTwo,";nicetobehere!

"）;

s1+=tempTwo;

cout<<"tempTwo:

\t"<

cout<<"S1:

\t"<

cout<<"S1[4]:

\t"<

s1[4]='x';

cout<<"S1:

\t"<

cout<<"S1[999]:

\t"<

MyStrings2（"AnothermyString"）;

MyStrings3;

s3=s1+s2;

cout<<"S3:

\t"<

MyStrings4;

s4="Whydoesthiswork?

";

cout<<"S4:

\t"<

return0;

}

程序运行输出：

S1:

initialtest

S1:

HelloWorld

tempTwo:

;nicetobehere!

S1:

HelloWorld;nicetobehere!

S1[4]:

o

S1:

HellxWorld;nicetobehere!

S1[999]:

!

S3:

HellxWorld;nicetobehere!

AnothermyString

S4:

Whydoesthiswork?

6-25编写一个3×3矩阵转置的函数，在main（）函数中输入数据。

解：

#include

voidmove（intmatrix[3][3]）

{

inti,j,k;

for（i=0;i<3;i++）

for（j=0;j

{

k=matrix[i][j];

matrix[i][j]=matrix[j][i];

matrix[j][i]=k;

}

}

voidmain（）

{

inti,j;

intdata[3][3];

cout<<"输入矩阵的元素"<

for（i=0;i<3;i++）

for（j=0;j<3;j++）

{

cout<<"第"<

<<"个元素为：

";

cin>>data[i][j];

}

cout<<"输入的矩阵的为：

"<

for（i=0;i<3;i++）

{

for（j=0;j<3;j++）

cout<

cout<

}

move（data）;

cout<<"转置后的矩阵的为：

"<

for（i=0;i<3;i++）

{

for（j=0;j<3;j++）

cout<

cout<

}

}

程序运行输出：

输入矩阵的元素

第1行第1个元素为：

1

第1行第2个元素为：

2

第1行第3个元素为：

3

第2行第1个元素为：

4

第2行第2个元素为：

5

第2行第3个元素为：

6

第3行第1个元素为：

7

第3行第2个元素为：

8

第3行第3个元素为：

9

输入的矩阵的为：

123

456

789

转置后的矩阵的为：

147

258

369

6-26编写一个矩阵转置的函数，矩阵的维数在程序中由用户输入。

解：

#include

voidmove（int*matrix,intn）

{

inti,j,k;

for（i=0;i

for（j=0;j

{

k=*（matrix+i*n+j）;

*（matrix+i*n+j）=*（matrix+j*n+i）;