课后题答案
C++语言程序设计复习课
一、第一章单选题
1．在每个C++程序中都必须包含有这样一个函数，该函数的函数名为( A )。
A．main B．MAIN C．name D．function
2．C++源程序文件的缺省扩展名为( A )。 A．cpp B．exe C．obj D．lik
3．程序运行中需要从键盘上输入多于一个数据时，各数据之间应使用(D )符号作为分隔符。
A．空格或逗号 B．逗号或回车 C．逗号或分号 D．空格或回车
4．C++程序的基本模块为（D ）。A．表达式 B．标识符 C．语句 D．函数
5．每个C++程序文件的编译错误分为（ B ）类。 //warning error
A．1 B．2 C．3 D．4
第二章单选题1．设x和y均为bool量，则x && y为真的条件是( A )。 C. 它们均为假 D. 其中一个为假
2．设x和y均为bool量，则x || y为假的条件是( C )。 A. 它们均为真 B. 其中一个为真
C. 它们均为假 D. 其中一个为假
3．设有语句“int a=12; a+=a*a;”，则执行结束后，a的值为( C )。 A. 12 B. 144 C. 156 D. 288
4．x>0 && x<=10的相反表达式为（ A ）。 A. x<=0 || x>10 B. x<=0 && x>10
C. x<=0 || x<=10 D. x>0 && x>10
5．x>0 || y==5的相反表达式为（ B）。 A. x<=0 || y!=5 B. x<=0 && y!=5
C. x>0 || y!=5 D. x>0 && y==5
第三章单选题1．当处理特定问题时的循环次数已知时，通常采用（ ）来解决。答案：A
A. for循环 B. while循环 C. do循环 D. switch语句
2．循环体至少被执行一次的语句为（ ）语句。答案：C
A. for循环 B. while循环 C. do循环 D. 任一种循环
3．在switch语句的每个case块中，假定都是以break语句结束的，则此switch语句容易被改写为(B）语句。 A. for B. if C. do D. while
4．for语句能够被改写为（ ）语句。答案：D
A. 复合 B. if C. switch D. while
5．循环语句“for(int i=0; i
6．下面循环语句执行结束后输出的i值为（ ）。答案：B for(int i=0; i
7．在下面循环语句中内层循环体S语句的执行总次数为（ ）。答案：D for(int i=0; i
-1)/2 D. n(n+1)/2
8．在下面的while循环语句中，其循环体被执行的次数为（ ）。答案：C int i=0,s=0; while(s<20){i++; s+=i;}//s=1,3,6,10,15,21 A. 4 B. 5 C. 6 D. 7
9．在下面的do循环语句中，其循环体被执行的次数为（ ）。答案：A int i=0; do i++; while(i*i<10);//i=0,1,2,3 A. 4 B. 3 C. 5 D. 2
第四章单选题
1．在下面的一维数组定义中，（ C ）语句有语法错误。 A. int a[]={1,2,3}; B. int a[10]={0} ; C. int a[]; D. int a[5];
2．在下面的二维数组定义中，（ ）语句是正确的。答案：C
A. int a[5][]; B. int a[][5]; C. int a[][3]={{1,3,5},{2}}; D. int a[](10);
3．在下面的字符数组定义中，（ ）语句有语法错误。答案：D
A. char a[20]=”abcdefg”; B. char a[]=”x+y=55.”; C. char a[15]={’1’,’2’}; D. char a[10]=’5’;
4．假定一个二维数组的定义语句为“int a[3][4]={{3,4},{2,8,6}};”，则元素a[1][2]的值为（ C ）。 A. 2 B. 4 C. 6 D. 8、
第五章单选题
1．下面的（ ）函数头格式不正确。答案：D
A．AA(int a, int b) B．AA(int a, int b=0) C．AA(int a=0, int b=0) D．AA(int a=0, int b)
2．下面的（ ）保留字不能作为函数的返回类型。答案：C
A．void B．int C．new D．long
3．下面的函数声明中，“void BC(int a, int b);”的重载函数是（ ）。答案：B
A．int BC(int x, int y); B．void BC(int a, char b);
C．float BC(int a, int b, int c=0);D．void BC(int a, int b=0);
4．声明或定义一个内联函数时，必须在函数开始使用保留字（ ）。答案：C
A．static B．const C．inline D．extern 5．在 下面的函数声明中，（ ）存在着语法错误。答案：D
A．int BC(int a, int); B．int BC(int, int);
C．int BC(int, int=5); D．int BC(int x; int y);
6．若定义了函数double *function(), 则该函数的返回值为（ ）。答案：B
A．实数型 B．实数指针型 C．函数指针型 D．数组型
7. 下列（ ）的调用方式是引用调用。答案：C
A．形参和实参都是变量 B．形参是指针，实参是地址值
C．形参是引用，实参是变量 D．形参是变量，实参是地址值
8．为了提高程序的运行速度，可将不太复杂的函数实现为（ ）。答案：A
A．内联函数 B．重载函数 C．递归函数 D．函数模板
9．下
面正确的函数原型语句是（ ）。答案：B
A．int Function(void a); B．void Function (int);
C．int Function(a); D．void int 10. 函数调用func((exp1,exp2), exp3*exp4-exp5)中所含实参的个数为( )个。答案：B
A．1 B．2 C．4 D．5
11. 若用数组名作为函数调用的实参，传递给形参的是（ ）答案：A
A．数组的首地址 B．数组中第一个元素的值
C．数组全部元素的值 D．数组元素的个数
12. 文件包含命令中被包含的文件的扩展名（ ）。答案：C
A．只能是.h B．不能是.h C．可以是.h或.cpp D．只能是.cpp
5．假定一个二维数组的定义语句为“int a[3][4]={{3,4},{2,8,6}};”，则元素a[2][1]的值为（A ）。 A. 0 B. 4 C. 8 D. 6
6．将两个字符串连接起来组成一个字符串时，选用（ C ）函数。
A. strlen() B. strcpy() C. strcat() D. strcmp()
第六章单选题
1．假定p是一个指向float型数据的指针，则p+1所指数据的地址比p所指数据的地址大( C )字节。 A．1 B．2 C．4 D．8
2．假定a为一个字符数组名，则元素a[8]相对于该数组首地址的字节地址为( )。答案：CB
A．4 B．8 C．16 D．32
3．假定a为一个整型数组名，则元素a[4]相对于该数组首地址的字节地址为( )。答案：CC
A．4 B．8 C．16 D．32
4．假定a为一个数组名，则下面的( )表示有错误。答案：CB
A．a[i] B．*a++ C．*a D．*(a+1)
5．用new运算符创建一维数组的正确语句是（ ）。答案：C
A．int *p=new a[10]; B.int *p=new float[10];
C．int *p=new int[10]; D.int *p=new int[5]={1,2,3,4,5}
第七单选题 1．当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为_____C_。 A．n B．n+1 C．n-1 D．n-2
2．假定AB为一个类，则该类的拷贝构造函数的声明语句为( )。答案：C
A．AB&(AB x); B．AB(AB x) C．AB(AB&); D．AB(AB* x)
3．对类对象成员的初始化是通过执行构造函数中的( )完成的。答案：A
A．初始化表 B．函数体 C．参数表 D．基类表
4．假定AB为一个类，则执行“AB a, b(3), *p;”语句时，自动调用该类构造函数的次数为( A)。
A．2 B．3 C．4 D．5
5．假定AB为一个类，则执行“AB a(4), b[3], *p
[2];”语句时，自动调用该类构造函数的次数为(B)。
A．3 B．4 C．6 D．9
6．假定AB为一个类，px为指向该类动态对象数组的指针，该数组长度为n，则执行 “delete []px;”语句时，自动调用该类析构函数的次数为( C )。 A．0 B．1 C．n D．n+1
7．对于类中定义的成员，其隐含访问权限为( )。答案：C
A．public B．protected C．private D．static
8．对于结构中定义的成员，其隐含访问权限为( )。答案：A
A．public B．protected C．private D．static
9．为了使类中的成员不能被类外的函数通过成员操作符访问，则不应把该成员的访问权限定义为( A)。 A．public B．protected C．private D．static
10．一个类的友元函数或友元类能够通过成员操作符访问该类的( )。答案：D
A．私有成员 B．保护成员 C．公用成员 D．所有成员
11．在一个类的定义中，通常要包含有（ ）成员的定义。答案：C
A．数据 B．函数 C．数据和函数 D．数据或函数
12．在类作用域中能够通过直接使用该类的（ ）成员名进行访问。答案：D
A．私有 B．公用 C．保护 D．任何
13．在关键字public后面定义的成员为类的（ ）成员。答案：B
A．私有 B．公用 C．保护 D．任何
14．在关键字private后面定义的成员为类的（ ）成员。答案：A
A．私有 B．公用 C．保护 D．任何
15．假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a的格式为（D ）。 A．x(a) B．x[a] C．x->a D．x.a
16．假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（B ）。 A．x.a B．x.a() C．x->a D．x->a()
第八单选题
1．假定一个结构类型的定义为 “struct A{int a,b; A* c;};”，则该类型的大小为________字节。答案：B
A．8 B．12 C．16 D．20
2．假定一个结构类型的定义为 “struct D{int a; union {int b; double c;};D* d[2];};”，则该类型的大小为____D___字节。A．8 B．12 C．16 D．20
3．假定有“struct BOOK{char title[40]; float price;}; BOOK *book;”，则不正确的语句为（ ）。答案：A
A．BOOK *x=new book; B．BOOK x={"C++ Programming",27.0};
C．BOOK *x=new BOOK; D．BOOK **x=&book;
4．假定有“struct BOOK{char title[40]; float pri
ce;}book;”，则正确的语句为（ ）。答案：B
A．BOOK &x= &book; B．BOOK &x=book;
C．BOOK &x=new BOOK; D．BOOK &x=BOOK;
第九章单选题1．当使用ifstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为( A)。
A. ios::in B. ios::out C. ios::in | ios::out D. ios::binary
2．当使用ofstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为( B)。答案：B
A. ios::in B. ios::out C. ios::in | ios::out D. ios::binary
3．当使用fstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为( D )。
A. ios::in B. ios::out C. ios::in | ios::out D. 没有
4. 当需要使用istrstream流类定义一个流对象并联系一个字符串时，应在文件开始使用#include命令，使之包含( D )文件。 A. iostream.h B. iomanip.h C. fstream.h D. strstrea.h
5．当需要使用ostrstream流类定义一个流对象并联系一个字符串时，应在文件开始使用#include命令，使之包含( C )文件。 A. iostream.h B. stdlib.h C. strstrea.h D. fstream.h
二、第一章填空题 1．C++语言是在_________语言的基础上发展起来的。答案：C
2．C++语言中的每条基本语句以________作为结束符。答案：;（或分号）
3．C++语言中的每条复合语句以________作为结束符。答案：}（或右花括号）
4．在C++每个程序行的后面或单独一行的开始使用注释的标记符为__________。答案：//
5．单行或多行注释的开始标记符为__________、结束标记符为__________。答案：/*、*/
6．在一个C++程序文件中，若要包含另外一个头文件或程序文件，则应使用以__________标识符开始的预处理命令。#include
7．C++程序中的所有预处理命令均以______字符开头。#
8．在#include命令中所包含的头文件，可以是系统定义的头文件，也可以是________定义的头文件。用户 （或编程者）
9．一个函数定义由________和________两部分组成。答案：函数头、函数体
10．用于输出表达式值的标准输出流对象是________，用于从键盘上为变量输入值的标准输入流对象是________。答案：cout、cin
11．当不需要函数返回任何值时，则应使用________标识符定义函数类型。答案：void
第二章填空题1．十进制数25表示成符合C++语言规则的八进制数为________。答案：031
2．十进制数25表示成符合C++语言规则的十六进制数为________。答案：0x19
3．在c++语言中，操纵符________表示输出一个换行符。答案：endl
4．执行“cout<
码为65~90，当执行“int x='C'+5;”语句后x的值为________。答案：72
6．已知'A'~'Z'的ASCII码为65~90，当执行“char ch=14*5+2;cout<
8．假定一个枚举类型的定义为“enum RB{a1,a2=3,a3,a4}x=a3;”，则x的值为________。答案：4
9．char、short、int、float、double类型的大小分别为________个字节。
10．十进制常数28和3.26的类型分别为________和________。答案：int、double
11．若需要定义一个常值常量，并且使C++能够进行类型检查，则应在定义语句的开始使用保留字__________。答案：const //#define MAX 100
12．使用const语句定义一个常值常量时，则必须对它同时进行_____。答案：初始化 //如const int MM=20;
13．执行“int x=45,y=13;cout<
16．假定y=10，则表达式++y*3的值为________。答案：33
17．表达式float(25)/4的值为________。答案：6.25
18．表达式int(14.6)%5的值为________。答案：4
19．表达式x=x+y表示成复合赋值表达式为__________。答案：x+=y
20．表达式x=x+1表示成增量表达式为__________。答案：++x
21．增量表达式++y表示成赋值表达式为__________。答案：y=y+1
22．关系表达式(x==0)的等价表达式为________。答案：(!x)
23．关系表达式(x!=0)的等价表达式为________。答案：(x)
24．假定不允许使用逻辑非操作符，则关系表达式x+y>5的相反表达式为____________。答案：x+y<=5
25．若x=5,y=10，则x>y逻辑值为________。答案：false 或0
26．若x=5,y=10，则x!=y的逻辑值为________。答案：true 或1
27．假定x=5，则执行“a=(x?10:20);”语句后a的值为________。答案：10
28．执行“typedef int DataType;”语句后，在使用int定义整型变量的地方都可以使用__________来定义整型变量。答案：DataType
第三章填空题1．在switch语句中，每个语句标号所含保留字case后面的表达式必须是_______。整型常量
2．在if语句中，每个else关键字与它前面同层次并且最接近的________关键字相配套。if
3．作为语句标号使用的C++保留字case和default只能用于________语句的定义体中。switch
4．执行switch语句时，在进行作为条件的表达式求值后，将从某个匹配的标号位置起向下执行，当碰到下一个标号位置时（停止/不停止）________执行。不停止
5
．若while循环的“头”为”while(i++<=10)”，并且i的初值为0，同时在循环体中不会修改i的值，则循环体将被重复执行______次后正常结束。11
6．若do循环的“尾”为”while(++i<10)”，并且i的初值为0，同时在循环体中不会修改i的值，则循环体将被重复执行______次后正常结束。10
7．当在程序中执行到________语句时，将结束本层循环类语句或switch语句的执行。答案：break
8．当在程序中执行到________语句时，将结束所在循环语句中循环体的一次执行。答案：continue
9．在程序中执行到________语句时，将结束所在函数的执行过程，返回到调用该函数的位置。答案：return
10．在程序执行完一个________函数调用后，将结束整个程序的执行过程，返回到操作系统或C++集成开发环境界面窗口。答案：主(或main)
第四章填空题 1．假定一个一维数组的定义为“char* a[8];”， 该数组所含元素的个数为________，所占存储空间的字节数为________。8、32
2. 假定一个二维数组的定义为“int a[3][5];”，则该数组所含元素的个数为________，所占存储空间的字节数为________。15、60
3. 执行“typedef int ABC[10];”语句把ABC定义为具有10个整型元素的________类型。数组
4. 使用“typedef char BB[10][50];”语句定义________为含有10行50列二维字符数组类型。BB
5. 存储字符’a’需要占用存储器的___个字节空间，存储字符串”a”需要占用存储器的__个字节空间。1、2
6. 字符串”a:\\xxk\\数据”的长度为________，存储它的字符数组的长度至少为________。11、12
7. 若a是一个字符数组，则从键盘上向该数组输入一个字符串的表达式语句为__________，向屏幕输出a中所存字符串的表达式语句为__________。答案：cin>>a; cout<
第五章填空题1．在C++语言中，一个函数由______和_______组成。答案：函数头、函数体
2．在函数外定义的变量称为全局变量，若没有被初始化则系统隐含对它所赋的初值为______。答案：0
3．函数被调用时，实参向形参的传送分为________和_______两种传送方式。答案：引用、值
4．重载一个函数的条件是：该函数必须在参数的_______或参数的_______上与其它同名函数有所不同。答案：个数、类型
5．如果一个函数只允许在同一程序文件中被调用，则应在该函数定义前加上的C++保留字为__.案：static
6．如果一个函数直接或间接地调用自身，这样的调用被称为____________调用。答案：递归
7．假定一个函数模板的定义为“template
cubin(T n){return n*n*n ;}”，则类型参数为_.案：T
8．对于无返回值函数，定义函数时要用__________作为函数类型。答案：void
9．函数形参的作用域是该函数的____________。答案：函数体
10．C++提供的预处理命令有宏定义命令，条件编译命令和____________。答案：文件包含命令
11．程序的编译是以__________为单位进行的。答案：文件
第六章填空题
1．假定p所指对象的值为25，p+1所指对象的值为46，则*p++的值为________。答案：25
2．假定p所指对象的值为25，p+1所指对象的值为46，则*++p的值为________。答案：46
3．假定p所指对象的值为25，p+1所指对象的值为46，则执行“(*p)++;”语句后，p所指对象的值为__26___。
4．假定p所指对象的值为25，p+1所指对象的值为46，则执行“*(p++);”语句后，p所指对象的值为__25____。
5．假定a是一个指针数组，则a+i所指对象的地址比a地址大________字节。答案：4*i
6．假定a是一个一维数组，则a[i]的指针访问方式为________。答案：*(a+i)
7．假定a是一个二维数组，则a[i][j]的指针访问方式为____________。答案：*(a[i]+j) 或*(*(a+i)+j)
第七章填空题1．假定要动态分配一个类型为Worker的具有n个元素的数组，并由r指向这个动态数组，则使用的语句表达式为Worker* r= _______________。答案：new Worker[n];
2．假定要访问一个结构x中的由a指针成员所指向的对象，则表示方法为____________。答案：n*(x.a)
3．假定要访问一个结构指针p所指对象中的b指针成员所指的对象，则表示方法为_ n*(p->b)
4．与结构成员访问表达式p->name等价的表达式是____________。答案：n(*p).name
5．与结构成员访问表达式(*fp).score等价的表达式是____________。答案：nfp->score
第八章填空题、1．在定义类对象的语句执行时，系统在建立每个对象的过程中将自动调用该类的____________，使其初始化。答案：构造函数
2．当一个类对象被撤消时将自动调用该类的____________。答案：析构函数
3．对基类数据成员的初始化是通过执行派生类构造函数中的____________来实现的。答案：初始化表
4．对一个类中的数据成员的初始化可以通过构造函数中的初始化表实现，也可以通过构造函数中的____________实现。答案：函数体
5．在一个派生类中，对基类成员、类对象成员和非类对象成员的初始化的过程中，首先是对________成员初始化。答案：基类
6．当撤消一个含有基类和类对象成员的派生类对象时，将首先完成派生类的析构函数定义体的执行。
7．设px是指向一个类动态对象的指针变量，则执行”delete px;”语句时，将
自动调用该类的___析构函数 8．假定一个类对象数组为A[N]，当离开它的作用域时，系统自动调用该类析构函数的次数为_N_。
9．假定用户没有给一个名为AB的类定义构造函数，则系统为其隐含定义的构造函数为_____。答案：AB(){}
10．假定用户没有给一个名为AB的类定义析构函数，则系统为其隐含定义的析构函数为__。答案：~AB(){}
11．假定一个类AB中有一个静态整型成员bb，在类外为它进行定义并初始化为0时，所使用的语句为________________。答案：int AB::bb=0;
12．假定类AB中有一个公用属性的静态数据成员bb，在类外不通过对象名访问该成员bb的写法为__。答案：AB::bb
13．如果一个派生类的基类不止一个，则称这种继承关系为____________。答案：多重继承
14．如果一个派生类只有一个唯一的基类，则称这样的继承关系为__________。答案：单继承
15．C++支持两种多态性：_________时的多态性和运行时的多态性。答案：编译
16．假定AA是一个类，“AA* abc();”是该类中一个成员函数的原型，则在类外定义时的函数头为__________________。答案：AA* AA::abc()
17．重载运算符时，其原有的__________、结合性以及操作对象的个数不允许改变。答案：优先级
18．一个双目运算符作为类的成员函数重载时有________个参数。答案：1
19．一个双目运算符作为独立函数重载时有________个参数。答案：2
三、程序运行结果
1. #include
void main()
{
int x=5;
switch(2*x-3) {
case 4: cout<
case 10: cout<<3*x-1<<’ ’; break;
default: cout<<"default"<
cout<<"switch end."<
第四章程序运行结果
1. #include
void main() {
int a[10]={12,39,26,41,55,63,72,40,83,95};
int i1=0, i2=0;
for(int i=0;i<10;i++)
if(a[i]%2==1) i1++; else i2++;
cout<
答案：6 4
2. #include
void main() {
int a[9]={36,25,48,14,55,40,32,66,60};
int b1, b2;
b1=b2=a[0];
for(int i=1;i<9;i++)
if(a[i]>b1) {if(b1>b2) b2=b1; b1=a[i];}
else if(a[i]>b2) b2=a[i];
cout<
答案：66 60
3. #include
void main() {
char a[]="abcdabcabfgacd";
int i1=0, i2=0, i=0;
while(a[i]) {
if(a[i]=='a') i1++;
if(a[i]=='b') i2++;
i++;
}
cout<
答案：4 3 14
第五章程序运行结果
#include
#include
double SD(double a, double b, char op) {
double x;
switch(op) {
case '+': x=a+b; break;
case '-': x=a-b; break;
case '*': x=a*b; break;
case '/': if(b) x=a/b; else exit(1);
break;
default: exit(1);
}
return x;
}
void main() {
int x=25,y=10;
cout<
答案：15 250 3.5
2．#include
void main() {
int a=10, b=20;
cout<
int b=a+35;
cout<
cout<
答案：
10 20
30 65
30 20
3．#include
void WF(int& x, int y) {
x=x+y;
y=x+y;
cout<
void main() {
int x=8, y=15;
cout<
x=2*x;
cout<
答案：
8,15
23,38
46,15
4．#include
void SelectSort(int a[], int n) {
int i,j,k;
for(i=1;i
for(j=i;j
}
}
void main() {
int i;
int a[6]={20,15,32,47,36,28};
SelectSort(a,6);
for(i=0; i<6; i++) cout<
答案：15 20 28 32 36 47
第六章程序运行结果
1．#include
void main() {
int a[8]={3,5,7,9,11,13,15,17};
int *p=a;
for(int i=0;i<8;i++) {
cout<
}
答案：
3 5 7 9
11 13 15 17
2．#include
void main() {
int a[9]={2,4,6,8,10,12,14,16,18};
for(int i=0;i<9;i+=2) cout<
答案：2 6 10 14 18
3．#include
void main() {
int x=20,y=40,*p;
p=&x; cout<<*p<<' ';
*p=x+10; cout<<*p<<' ';
p=&y; cout<<*p<
答案20 30 40
30 60
4. #include
int LB(int *a, int n) {
int s=1;
for(int i=0;i
}
void main() {
int a[]={1,2,3,4,5,6,7,8};
int b=LB(a,5)+LB(&a[3],3);
cout<<"b="<
答案：b=240
七章程序运行结果
1. #include
struct Worker {
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
void main() {
Worker x={"wangfong",43,1640};
Worker y, *p;
y=x; p=&x; p->pay+=100;
cout<
答案：
wangfong 43 1640
wangfong 45 1940
2. #inc
lude
#include
struct Worker {
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
bool operator==(Worker& r1, Worker& r2) {
if(strcmp(https://www.wendangku.net/doc/1616609205.html,, https://www.wendangku.net/doc/1616609205.html,)==0) return true;
else return false;
}
void main() {
Worker a[4]={{"abc",25,420},{"def",58,638},
{"ghi",49,560},{"jkl",36,375}};
Worker x={"ghi"};
for(int i=0; i<4; i++) if(a[i]==x) break;
cout<
答案：ghi 49 560
3. #include
struct Worker {
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
bool operator <(Worker& r1, Worker& r2) {
if(r1.age
}
void main() {
Worker a[4]={{"abc",25,420},{"def",58,638},
{"ghi",49,560},{"jkl",36,375}};
Worker x=a[0];
for(int i=1; i<4; i++) if(x
答案：def 58 638
第八章程序运行结果
1．#include
class A {
int a,b;
public:
A() {a=b=0;}
A(int aa, int bb) {
a=aa; b=bb;
cout<
};
void main() {
A x,y(2,3),z(4,5);
}
答案：
2 3
4 5
2．#include
class A {
int a,b;
public:
A(int aa=0, int bb=0): a(aa), b(bb) {
cout<<"Constructor!"<
};
void main() {
A x,y(2,3),z(y);
}
答案：
Constructor!0
Constructor!5
3．#include
class A {
int* a;
public:
A(int aa=0) {
a=new int(aa);
cout<<"Constructor!"<<*a<
};
void main() {
A x[2];
A *p=new A(5);
delete p;
}
答案：
Constructor!0
Constructor!0
Constructor!5
4．#include
class A {
int a;
public:
A(int aa=0): a(aa) {}
~A() {cout<<"Destructor!"<
void main() {
A x(5);
A *p=new A(10);
delete p;
}
答案：
Destructor!10
Destructor!5
5. #include
class A {
int* a;
public:
A(int x) {
a=new int(x);
cout<<"Constructor!"<<*a<
~A() {delete a; cout<<"Destructor!"<
void main() {
A x(3), *p;
p=new A(5);
delete p;
}
答案：
Constructor!3
Constructor!5
Destructor!
Destructor!
6. #include
class A {
int a;
public:
A(int aa=0): a(aa) {
cout<<"Constructor A!"<
};
class B: public A {
int b;
public:
B(int aa, int bb): A(aa), b(bb) {
cout<<"Constructor B!"<
};
void main() {
B x(2,3), y(4,5);
}
答案：
Constructor A!2
Constructor B!3
Constructor A!4
Constructor B!5
第九章程序运行结果
1．#include
void main() {
int x=25,y=120;
cout<<"dec:"<
答案：
dec: 25 120
oct: 31 170
hex: 19 78
2. #include
void main() {
struct AB {char aa[15]; int bb;};
AB a[4]={{"Apple",25},{"Peach",40},//苹果、桃
{"Pear",36},{"Tomato",62}}; //梨、西红柿
cout.setf(ios::left);
for(int i=0;i<4;i++) {
cout<
}
答案：
Apple 25
Peach 40
Pear 36
Tomato 62
四、三章编写函数
1.编写一个主函数，利用while循环，求出并显示满足不等式1+1/2+1/3+...+1/n≥5的最小n值。
答案：
void main(){
int i=0; double s=0;//或int i=1; double s=1;
while(s<5) s+=double(1)/++i;
cout<<"n="<
2. 编写一个主函数，计算1+3+3^2+...+3^10的值并输出，假定分别用i,p,s作为循环变量、累乘变量和累加变量的标识符。
void main(){
int i; //用i作为循环变量
int p=1; //用p作为累乘变量
int s=1; //用s作为累加循环变量
for(i=1;i<=10;i++) {p*=3; s+=p;}
cout<
3．编写一个主函数，已知6≤a≤30,15≤b≤36，求出满足不定方程2a+5b=126的全部整数组解。如(13,20)就是其中的一组解。
答案：
void main()
{
int a,b;
for(a=6;a<=30; a++)
for(b=15;b<=36;b++)
if(2*a+5*b==126) cout<<'('<
六、第四章编写程序
1. 编写一个函数，函数头格式为“void fun4(char* a, int b[])”，分别求出由字符指针a所指向的字符串中包含的每种十进制数字出现的次数，把统计结果保存在数组b的相应元素中。
答案：
void fun4(char* a, int b[])
{
int i;
for(i=0;i<10;i++) b[i]=0;//对b数组初始化
while(*a) {
int j=*a-’0’;
if(j>=0 && j<=9) b[j]++;
a++;
}}
四、第三章函数功能
1．#include
int SA(int a, int b) {
if(a>b) return 1;
else if(a==b) return 0;
else return -1;
}
答案：比较两个整型参数a和b的大小，若a>b则返回1，若a==b则返回0，若a
if(a>=b && a>=c) return a;
if(b>=a && b>=c) return b;
return c;
}
答案：求出a,b,c三个数中的最大值并返回。
3．int SE(int n) {//n为大于等于1的整数
int x; cin>>x;
if(n==1) return x;
int m=x;
while(--n) {cin>>x; m+=x;}
return m;
}
答案：求出从键盘上输入的n个整数之和并返回。
4．double SF(double x, int n) {//n为大于等于0的整数
double p=1,s=1;
for(int i=1;i<=n;i++) {p*=x; s+=p/(i+1);}
return s;
}
答案：计算1+x/2+x2/3+...+xn/(n+1)的值并返回。
5．#include
bool SG(int x) {//x为大于等于2的整数
int a=int(sqrt(x)); //取x的平方根
int i=2;
while(i<=a) {if(x%i==0) break; i++;}
if(i<=a)return 0; else return 1;
}
答案：判断x是否为一个质数，若是则返回1，否则返回0。
6．float FH() {
float x,y=0,n=0;
cin>>x;
while(x!=-1) {n++; y+=x; cin>>x;}
if(n==0) return y; else return y/n;
}
答案：求出从键盘上输入的一批常数的平均值，以-1作为结束输入的标志。
7．float FI(int n) {//n为大于等于1的整数
float x,y=0;
do {
cin>>x; y+=x*x;
} while(--n>0);
return y;
}
答案：求出从键盘上输入的n个常数的平方和并返回。
8．#include
#include
void main()
{
int x,y;
cin>>x;
y=int(sqrt(x));//sqrt(x)为求x的算术平方根
for(int i=1;i<=y;i++)
if(x%i==0) cout<<”x=”<
答案：把从键盘上输入的一个整数x分解为所有可能的每两个因子之积。
第五章函数功能
1．bool WB(int a[], int n, int x) {
for(int i=0;i
return false;
}
答案：从数组a中顺序查找值为x的元素，若查找成功则返回真，否则返回假。
2．template
int fun8(T a[], int n, T key)
{
int c=0
for(int i=0;i
return c;
}
答案：函数模板，从一维数组a[n]中统计出其值大于等于key的元素个数并作为函数值返回。
3．#include
template
int WG(TT a, TT b) {
if(a>b) return 1;
else if(a==b) return 0;
else return -1;
}
答案：
模板函数，比较两个变量a和b的大小，若a>b则返回1，若a==b则返回0，若a
void WE(Type a[], Type b[], int n) {
for(int i=0;i
}
答案：模板函数，把数组a的每个元素按逆序放入数组b中。
第六章写出函数功能
1. #include
int* LJ(int a[], int n) {
int k=0;
for(int i=1;i
if(a[i]>a[k]) k=i;
return &a[k];
}
答案：求出数组a中n个元素的最大值元素，返回该元素的地址。
2. #include
void LI(int n) {
int* a=new int[n];
for(int i=0;i
for(i=n-1;i>=0;i--) cout<<*(a+i)<<' ';
cout<<'\n';
delete []a;
}
答案：把从键盘上输入的n个整数按与输入的相反次序显示出来。
3. void LK(int a[], int n, int& m) {//int a[]同int*a
float s=0; int i;
for(i=0;i
for(i=0,m=0;i
}
答案：求出数组a的n个元素中大于等于平均值的元素个数，该个数由引用参数m返回。
第七章写出函数功能
1．void QA(Worker a[], int n) {
for(int i=0; i
}
假定结构类型Worker 的定义如下：
struct Worker {
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
答案：从键盘输入n个Worker类型的记录到一维数组a中。
2．istream& operator>>(istream& istr, Worker& x) {
cout<<"请输入一个职工记录：姓名、年龄、工资"<
return istr;
}// Worker a; cin>>a;
假定结构类型Worker 的定义如下：
struct Worker {
char name[15]; //姓名
int age; //年龄
float pay; //工资
};
答案：重载提取操作符，用于从输入流中输入一个Worker类型的记录到x中。
3．void QB(StrNode*& f, int n) {
if(n==0) {f=NULL; return;}
f=new StrNode;
cin>>f->name;
StrNode* p=f;
while(--n) {
p=p->next=new StrNode;
cin>>p->name;
}
p->next=NULL;
}
假定结构类型StrNode的定义如下：
struct StrNode {
char name[15]; //字符串域
StrNode *next; //指针域
};
答案：建立一个具有n个结点的链表，每个结点的字符串值由键盘输入，链表的表头指针由引用变量f带回。
4．void QC(StrNode* f) {
while(f) {
cout<
f=f->next;
}
}
假定结构类型StrNode的定义如下：
struct StrNode {
char name[15]; //字符串域
StrNode *next; //指针域
};
答案：遍历f单链表，即从表头结点开始依次输出f单链表中每个结点的值。
5．IntNode* FindMax(IntNode *f)
{
if(!f) return NULL;
IntNode *p=f;
f=f->next;
while(f) {
if(f->data>p->data) p=f;
f=f->next;
}
return p;
}
假定IntNode的类型定义为：
struct IntNode {
int data; //结点值域
IntNode* next; //结点指针域
};
答
案：从表头指针f指向的、由IntNode类型的结点所构成的链表中查找出data域的值最大的结点并返回指向该结点的指针。
6．int Count(IntNode *f) {
if(!f) return 0;
int c=0;
while(f) {c++; f=f->next;}
return c;
}
假定IntNode的类型定义为：
struct IntNode {
int data; //结点值域
IntNode* next; //结点指针域
};
答案：统计出以表头指针为f的链表中结点的个数。
7．void Output(IntNode *f) {
if(!f) return;
while(f) {
cout<
f=f->next;
}
cout<
假定IntNode的类型定义为：
struct IntNode {
int data; //结点值域
IntNode* next; //结点指针域
};
答案：对于以表头指针为f的链表，依次显示出每个结点的data域的值。
第九章每个函数功能
1．#include
#include
#include
void JA(char* fname) {
ofstream fout(fname);
char a[20]; cin>>a;
while(strcmp(a,"end")!=0) {
fout<
}
fout.close();
}
答案：从键盘上输入一组字符串到fname所指字符串作为文件名的文件中，直到输入标志结束的字符串"end"为止。
2．#include
#include
void JB(char* fname) {//假定文件中保存的每个字符串长度小于20
ifstream fin(fname);
char a[20]; int i=0;
while(fin>>a) {cout<
cout<<"字符串个数："<
答案：向字符串文件fname中依次读取每个字符串并输出到屏幕上显示出来，同时统计并显示出文件中所含字符串的个数。
- 《台阶》课后练习题答案
- (完整版)《台阶》导学案及答案
- 《台阶》阅读练习题附答案
- 《台阶》作业题(含答案)1
- 八年级语文上册第8课《台阶》练习题新人教版(含参考答案)
- 部编七年级下语文练习答案11 台阶(2020)
- 《台阶》练习题及参考答案
- 台阶中考现代文阅读练习及答案
- 七下语文课时练答案人教版_七年级语文台阶课后练习题附答案
- 【七】人教版新版七年级下册语文《台阶》习题精选及答案
- 《台阶》课后练习题
- 《天窗》练习题课后练习题及答案编制者复旦中学陆增堂
- (完整版)台阶练习题
- 台阶练习题附参考答案
- 台阶练习题及答案
- 《台阶》课后练习题答案
- 8-台阶练习题及答案
- 《台阶》课后练习题答案
- 《台阶》课后练习题.docx
- [汇总]台阶课后练习题答案.docx