第四至五章 习题答案

第四章函数与程序结构

一、填空题

1.函数的返回值是通过函数中的语句获得的，因此，当函数有返回值时，函数体内要有该语句。

2.根据变量定义位置的不同，可分为和。

3.一个程序将操作系统分配给其运行的内存块分为、、和栈区。

4.C++提供的编译预处理功能主要有以下3种：、及条件编译命令。

5.递归调用的执行过程分为和。

二、简答题

1.函数的返回类型有几种？它们的含义和使用方法是什么？

2.C++中参数传递机制有几种？分别简述这些机制。

3.标识符作用域的分类，并简述这些分类。

4.内联函数的概念是什么？为什么要引入内联函数？

5.什么是函数重载，并简述重载函数的目的以及参数满足的条件。

6.简述重载函数的匹配顺序。

三、编程题

1.编写一个函数统计任意一个字符串中字母、数字、其他字符出现的频率。

2.设有10名学生3门考试课，编写一函数输出平均分不及格的学生。

3.编程实现用弦截法求方程x3-5x2+16x-80=0在区间[2，6]内的根。

4.使用函数重载的方法，设计两个求面积函数。

5.假设某企业有:

①财务管理;

②工程管理;

③市场管理;

三方面管理事务,开发具有菜单功能的程序框架，实现选择这三方面的管理。具体管理内容此处不予考虑。

参考答案

一、填空

1. return

2.局部变量全局变量

3.代码区全局数据区堆区

4.宏定义命令文件包含命令

5.递推过程回归过程

二、简答题

１.答：函数的返回值有下面几种情形：

（1）返回void 类型

如果函数无值返回，应说明为void 类型。例如：

void print（）｛cout<<″Hello World !″｝；

void show（）{ cout<<″Wonderful C++!″}；

函数仅需完成打印和显示工作，不需返回任何数据，这类函数调用一般形成一个函数调用语句。未作类型说明的函数，系统认为是int 类型函数，应返回一整型值。

（2）返回数值类型

最常见的函数是返回一个数值的函数。例如：

int add（int a，int b）；

float cuberoot（float x）；

这类函数的调用表达式可以出现在表达式语句中。当函数要返回的数值不止一个时，情况比较复杂，一般它可以以结构或类的形式，也可以以结构，数组或对象指针类型方式实现。（3）返回引用类型

C++语言提供的引用返回概念是其特有的一种很强的功能，当函数定义中把该函数说明为某类型的引用类型时，该函数调用后返回的不单是值，而是包含返回值的变量（或对象）。２.答：参数传递机制有值调用和引用调用

（１）值调用

值调用实参与形参的结合过程：调用函数时，系统为形式参数分配新的存储单元，将实参的值赋给形参后，被调函数中的操作是在形参的存储单元中进行的，当函数调用结束时释放形参所占的存储单元。因此，在函数中对形参值的任何修改都不会影响到实参的值。

（２）引用调用

引用是指在程序中为一个变量取一个别名，以便在不同的情况下使用，对引用的操作也就是对目标变量的操作，他们代表着同一存储单元。因此，当形参被定义为引用类型，则对形参的任何操作都意味着对相应实参的操作，实参的值将随函数体内对形参的改变而改变。３.答：标识符作用域共分成块作用域、文件作用域、函数声明（原型）作用域、函数作用域、类作用域五种。

（1）块作用域

块是用花括号括起来的一段程序。在块内说明的变量具有块作用域，其作用域是从变量说明处到块的结束处（即块的右花括号处）。

（2）文件作用域

文件作用域也称全局作用域，定义在所有函数之外的标识符，具有文件作用域，作用域为从定义处到整个源文件结束。文件中定义的全局变量和函数都具有文件作用域。

（3）函数声明作用域

在进行函数声明时，形参作用域只在声明中，即作用域结束于右括号。正是由于形参不能被程序的其他地方引用，所以通常只要声明形参个数和类型，形参名可省略。

（4）函数作用域

函数中定义的变量，包括形参和函数体中定义的局部变量，作用域都在该函数内，也称作函数域。

（5）类作用域

类作用域是指类定义范围（包括类的声明部分和相应成员函数实现整个范围）。在该范围内，类的成员函数对数据成员有无限访问权限。

4.答：内联函数也称为内嵌函数，在使用内联函数时，C++编译器用函数体中的代码插入到调用该函数的语句之处，在程序运行时不再进行函数调用，从而消除函数调用时的系统开销，提高程序执行效率。

函数的使用可以减少程序的目标代码，实现程序代码共享，为编程带来方便。但在程序

执行过程中调用函数时，系统要将程序当前的一些状态信息保存到堆栈中，同时转到被调函数的代码处去执行函数体语句，这些参数保存与传递的过程中系统需要时间和空间的开销，使程序执行效率降低。特别是对于那些代码较短而又频繁调用的函数，这个问题尤为严重。为了解决这一问题，C++引入了内联函数。

5.答：在C++中，两个或两个以上的函数可以重名，但要求函数的参数说明不同，如参数的类型不同，参数的个数不同等。这种共享同名函数称为函数重载。重载函数的意义就在于，可以用同一个函数名字访问多个相关函数，编译器能够根据参数的具体情况决定由哪个函数执行操作。函数重载有助于解决复杂问题。

对于函数重载问题，要区分函数名相同的函数，只有从它的参数上进行区分。具体地说，要实现函数重载，它们的参数必须满足以下两个条件之一：

①参数的个数不同。

②参数的类型不同

６.答：重载函数选择的规则是按下述顺序将实参类型与被调用的重载函数形参类型一一比较。

（1）寻找一个严格的匹配，即：调用与实参的数据类型、个数完全相同的那个函数。

（2）通过内部转换寻求一个匹配，即：通过（1）的方法没有找到相匹配的函数时，则由C++系统对实参的数据类型进行内部自动转换，转换完毕后，如果有匹配的函数存在，则执行该函数。

（3）对实参进行强制类型转换，以此作为查找相匹配的函数。

三、编程题

1. 程序如下：

#include

#include

void count(char letter[ ])

{ int i,t1,t2,t3,n;

i=0; t1=0;

t2=0; t3=0; n=0;

while(letter[i]!='\0')

{

if((letter[i]>='a'&&letter[i]<='z')|| (letter[i]>='A'&& letter[i]<='Z'))

t1++;

else if (letter[i]>='0'&& letter[i]<='9')

t2++;

else

t3++;

i++;

}

n=t1+t2+t3;

cout<<"字母出现的频率为："<

cout<<"数字出现的频率为："<

cout<<"数字出现的频率为："<

}

void main( )

{

char str[80];

gets(str);

count(str); //采用传址调用}

2.程序如下：

#include

using namespace std;

void average(int score[][3], int pNum, int cNum);

void main()

{

const int n=4;

const int m=3;

int a[n][m];

cout<<"请输入10个学生3门课程成绩：\n";

for(int i=0;i

for(int j=0;j

cin>>a[i][j];

cout<

average(a,m,n );

}

void average(int score[][3], int pNum, int cNum)

{

for(int i=0;i

{

int sum=0;

for(int j=0;j

sum+=score[i][j];

if (double(sum)/cNum<60)

cout<<"第"<

}

}

3.程序如下：

#include

float f(float x)

{

float y;

y=((x-5.0)*x+16.0)*x-80.0;

return(y);

}

float xpoint(float x1,float x2)

{

float y;

y=(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1));

return(y);

}

float root(float x1,float x2)

{

float x,y,y1;

y1=f(x1);

do

{

x=xpoint(x1,x2);

y=f(x);

if(y*y1>0)

{

y1=y;

x1=x;

}

else x2=x;

}while(fabs(y)>=0.0001);

return(x);

}

#include

void main()

{

float x1=2,x2=6,x;

x=root(x1,x2);

cout<<"A root of equation is:"<

}

4.程序如下：

#include

const double PI=3.1415;

double area(float r) //求圆面积，需传递一个参数

{

return(PI*r*r);

}

double area(float x,float y) //求矩形面积，需传递两个参数{

return(x*y);

}

void main( )

{

float a,b,r;

cout<<"输入圆半径";

cin>>r;

cout<<"圆面积:"<

cout<<"输入矩形长宽";

cin>>a>>b;

cout<<"矩形面积:"<

}

5.程序如下：

#include

void menu_print(); //函数声明

void account_report(); //函数声明

void engineering_report(); //函数声明

void marketing_report(); //函数声明

int main()

{

int choice;

do{

menu_print();

cin>>choice;

}while(choice<=0||choice>=4);

switch(choice)

{

case 1: account_report(); break;

case 2: engineering_report(); break;

case 3: marketing_report(); break;

}

return 0;

}

void menu_print()

{

cout<<"系统功能："<

cout<<"1.财务管理"<

cout<<"2.工程管理"<

cout<<"3.市场管理"<

cout<<"选择业务序号：";

}

void account_report()

{

cout<<"生成财务管理"<

}

void engineering_report()

{

cout<<"生成工程管理"<

}

void marketing_report()

{

cout<<"生成市场管理"<

}

第五章构造数据类型

一、选择题

1. 若有如下定义，则下列对成员变量a的访问，哪种是不合法的【】

struct AA{

int a,b;

}st,*p=&st;

A. (*p).a

B. *p.a

C. p->a

D. st.a

2. 若有以下结构体的定义：

Struct Student{

int num;

char name[8];

double score;

}stu,*p=&stu,stu2;

下列语句中，【】是错误的。

A. stu.num=10;

B. stu=”Li Feng”;

C. p->score=87.5;

D. stu2=stu1;

3. 若有如下函数原型的定义：

Void fun(Student *s,int n);

Student是结构体类型名，stu是结构体类型的变量，*p是指向stu变量的指针，下列那个调用是合法的【】。

Ａ. fun(stu,5); B. fun(&stu,5); Ｃ. fun(*p,5); Ｄ. fun(Student stu,5);

4. 若有以下程序代码：

#include

void main(){

union BB{

int n; char c;

}s;

s.n=65;

cout<

}

则该程序的输出结果是【】

A. 65 A

B. 65 65

C. A A

D. A 65

5. 在int a=5,*p=&a; 语句中，*p的值是【】

A. 变量a的地址

B. 无意义

C. 变量p的地址值

D. 5

6. 对于语句int *p[5]; 的描述【】是正确的。

A. p是一个指向数组的指针，所指向的数组是５个int型元素

B. p是一个指向某数组中第５个元素的指针，该元素是int型变量

C. p[5]表示某个数组的第５个元素

D. p是一个具有５个元素的指针数组，每个元素是一个int型指针

7. 若有char *a[2]={"asdf","ASDF"} ; 则下面的表述正确的是【】

A. a数组元素的值分别是"asdf"和"ASDF"

B. a是指针变量，它指向含有两个数组元素的字符型一维数组

C. a数组的两个元素a[1]、a[2]分别存放的是含有４个字符的一维字符数组的首地址

D. a数组的两个元素中各自存放了字符'a'和'A'的地址

二、填空题

1. ___________中的每一个元素必须是同一种数据类型，___________中允许将不同类型的数据组合成一种数据结构。

2. ___________变量中，变量的地址和它的各成员地址是同一个地址。

3. 枚举变量的值是一个___________值。

4. 有如下结构体的定义：

struct AA{

int *a，b;

char c;

};

则sizeof(AA)的值是___________。

5. 有如下联合体的定义：

union DD{

int d;

double e;

char f[6];

};

则sizeof(DD)的值是___________。

6. 若有int a[6],*p=a;，则数组元素a[3]可以表示为*(p+ ) 或p[ ]。

7. 使用动态存储分配机制可以使程序在运行时根据具体情况灵活调整分配情况，它是主要通过运算符和完成的。

8. 若有：

char *s="1234567";

s+=3;

则此时cout<

9. 函数指针是函数在内存中的，在程序中，用表示。

三、阅读程序，写出运行结果

1．#include

void main()

{

int j,k;

int str[ ]={2,－4,5,15,19,－11,16,7};

for(j=0,k=j;j<8;j++)

if(str[j]>str[k])

k=j;

cout<

}

2．#include

void main()

{ struct s1{

char c[4],*a;

}t1={"abc","def"};

struct s2{

char *p;

s1 ss1;

}t2={"ghi",{"jkl","mno"}};

cout<

cout<

cout<

cout<<++t2.p<<++t2.ss1.a<

}

3．#include

struct XX{

int a;

char *b;

}s;

void fun(XX f);

void main()

{ s.a=10;

s.b="efgh";

fun(s);

cout<

}

void fun(XX f){

f.a=5;

f.b="abcd";

cout<

}

四、编程题

1．有一个3×4的矩阵，要求编程求出其中值最大的那个元素的值，以及其所在的行号和列号。

2．输入一个字符串，统计其中包含的单词个数，假定单词与单词之间用空格分隔。

3．建立一个简单的通讯录的查询系统。每个人的记录包括姓名、性别、年龄、电话等内容，要求把记录定义成结构体类型。输入各人信息，当给出姓名、年龄、电话等时，能输出找到或未找到的信息。若找到，输出此人的信息。要求用指向结构体数组的指针作为函数参数，在主函数中定义结构体数组，调用函数实现通讯录的查询。

4．利用指针作参数，编写一个对3个整型变量排序的程序。

5．用返回指针类型的函数实现数组中的最大元素值。

参考答案

一、选择题

1.B

2.B

3.B

4.A

5.D

6.D

7.D

二、填空题

1．数组结构体

2．联合体类型

3．常量

4．12

5．8

6．3 3

7．new delete

8．4567

9．地址函数名

三、阅读程序，写出运行结果。

1．运行结果：

4

2．运行结果：

ad

abcdef

ghimno

hino

3．运行结果：

5abcd

10efgh

四、编程题

1．参考程序：

#include

void main ()

{

int i,j,row=0,colum=0,max ;

static int

a[3][4]={{1,2,3,4},{9,8,7,6},{-10,10,-5,2}};

max=a[0][0];

for(i=0;i<=2;i++)

for (j=0;j<=3;j++)

if(a[i][j]>max)

{

max=a[i][j];

row=i;

colum=j;

}

cout<<"max="<

cout<<"row="<

cout<<"colum="<

}

运行结果为：

max=10

row=2

colum=1

2．参考程序：

#include

void main()

{

char string[81];

int i,num=0,word=0;

char c;

cin.get(string,81);

for(i=0;(c=string[i])!='\0';i++)

if(c==' ') word=0;

else if(word==0)

{

word=1;

num++;

}

cout<<"There are "<

}

3．参考程序：

#include

#include

#define N 5

struct person

{

char name[10];

int age;

char sex;

char phone[16];

};

void display(person *p,int i)

{

cout<

}

void search1(person *p,int n)

{

char name[8];

int k=0;

cout<<"请输入姓名：";

cin>>name;

for(int i=0;i

if(strcmp(p[i].name,name)==0)

{

k++;

display(p,i);

}

if(k==0)

cout<

}

void search2(person* p,int n)

{

int age,k=0;

cout<<"请输入年龄:";

cin>>age;

for(int i=0; i

if(p[i].age==age)

{

k ++;

display(p,i);

}

if(k==0)

cout<

}

void search3(person* p,int n)

{

char phone[16];

int k=0;

cout<<"请输入电话：";

cin>>phone;

for(int i=0;i

if(strcmp(p[i].phone,phone)==0)

{k++;

display(p,i);

}

if(k==0)

cout<

}

void main(){

struct person

per[N]={{"zhang",33,'m',"7655949"},{"wang",32,'f',"7655643"}, {"li",33,'m',"7765392"},{"zhao",33,'f',"7655673"}, {"chen",33,'f',"3824729"}};

int number,flag=1;

while(flag)

{ cout<<"请输入要查询的方式:"<

cout<<"1-姓名 3-电话" <

cout<<"2-年龄 0-退出"<

cout<<"输入你的选择(0-3)：";

cin>>number;

while(number<0||number>3)

{ cout<<"请重新输入你的选择(0-3)：";

cin>>number;

}

cout<

switch(number)

{ case 1:

cout<<"按姓名查询..."<

search1(per,N);

break;

case 2:

cout<<"按年龄查询..."<

search2(per,N); //调用修改指定记录数据的函数 break;

case 3:

cout<<"按电话查询..."<

search3(per,N);

break;

case 0://结束

cout<<"本次处理结束。bye-bye"<

flag=0;

}

}

}

该程序的运行结果如图所示。

4．参考程序：

#include

void swap(int *xp,int *yp)

{

int tmp;

tmp=*xp;

*xp=*yp;

*yp=tmp;

}

void sort(int *x,int *y,int *z)

{

if(*x>*y) swap(x,y);

if(*x>*z) swap(x,z);

if(*y>*z) swap(y,z);

}

void main()

{

int a=15,b=6,c=7;

cout<<"交换前"<

cout<

sort(&a,&b,&c);

cout<<"交换后"<

cout<

}

5．参考程序：

#include

const int n=10;

float *max(float a[],int m)

{

float *k,*p;

for(p=a,k=a;p

if(*p>*k) k=p;

return k;

}

void main()

{

float x[n];

int j;

for(j=0;j

cin>>x[j];

cout<<*max(x,n)<

}