第三章　习题

 

一、             选择填空

1.       预处理命令在程序中都是以（  ）开头的。

A.  * ;         B. # ;   C . : ;      D. / ;

2.       文件包含命令中被包含的文件的扩转名（  ）。

A.必须为.h;       B.不能用.h;    C .必须是.c;   D.不一定是.h;

3.       下列条件编译命令中

#if()

<语句序列1>

#else

<语句序列2>

#endif

A.整常量表达式；    B.任何标识符;       C .任意表达式      ;      D.被定义的宏名;

4.       带参数的宏定义中，程序中引用宏定义的实参（  ）。

A.只能是常量;   B.只能是整型量;   C .只能是整形表达式;  D.可以是任意表达式;

5.       下列（  ）是语句

A. ；; B.a=17;   C .x+y;   D. cout<<”\n”;

6.       下列for循环的次数为（  ）。

for(int i(0),x=0;!x&&i<=5;i++)

A.5;  B.6; C .1;       D.无限;

7.       下列while循环的次数是（  ）。

while(int i=0)i- -;

A.0; B.1; C .5 ;      D.无限;

8.       下列do-while循环的循环次数为（  ）。

已知：int i(5);

do{cout<<i- - <<endl;

i- - ;

}while(i!=0);

A.0;  B.1; C .5;       D.无限;

9.        下列for循环的循环体执行次数为（  ）。

for(int i(0),j(10);i=j=10;i++,j- -) 

A.0;  B.1; C .10;     D.无限;

10.   已知：int a,b;下列switch语句中，(  )是正确的。

A.      switch(a);

{case a:a++;break;

case b:b++;break;

}    

B.      switch(a+b)

{ case 1:a+b;break;

case 2:a-b

}|

C.      switch(a*a)

{case1,2:++a;

case3,4:++b;

}

D.     switch(a/10+b)

{case 5:a/5;break

default:a+b;

}

11.   下述关于循环体的描述中，（  ）是错误的。

A.      循环体中可以出现break语句和continue语句；

B.      循环体中还可以出现循环语句；

C.      循环体中不能出现goto语句;

D.     循环体中可以出现开关语句。

12.   下述关于goto语句的描述中，（  ）是正确的。

A.      goto语句可在一个文件中随意转向；

B.      goto语句后面要跟上一个他所转向的语句；

C.      goto语句可以同时转向多条语句；

D.     goto语句可以从一个循环体内转到循环体外。

13.   下述关于break语句的描述中，（  ）是正确的。

A.      break语句可用于循环体内，它将退出该重循环；

B.      break语句可用于开关语句中，它将退出开关语句。

C.      break语句可用于if体内,它将退出if语句;

D.     break语句在一个循环体内可以出现多次。

14.   下述关于开关语句的描述中，（  ）是正确的。

A.      开关语句中default子句可以没有，也可以有一个;

B.      开关语句中每个语句序列中必须有break语句;

C.      开关语句中default子句只能放在最后；

D.     开关语句中case子句后面的表达式可以是整形表达式。

15.   下列关于条件语句的描述中，（　　）是错误的。

A.      if语句中只有一个else子句；

B.      if语句中可以有多个else if子句；

C.      if语句中if体内不能是开关语句；

D.     if语句中的if体中可以是循环语句。

二、   判断下列描述是否正确，对者划√，错者划×。

１．  预处理命令是在进行编译时首先执行的，然后再进行正常编译。√

２．  宏定义命令是以分号结束的。×

３．  带参数的宏定义只能有1至2个参数。×

４．  文件包含命令所包含的文件是不受限制的。×

５．  条件编译命令只在编译时才有作用。√

６．  预处理命令的主要作用是提高效率的。×

７．  复合语句就是分程序。×

８．  条件语句不能作为多路分支语句。×

９．  开关语句不可以嵌套，在开关语句的语句序列中不能再有开关语句×

10．开关语句中的default关键字，只能放在该语句的末尾，不能放在开头或中间。×

11．Switch语句中必须有break语句否则无法退出switch语句。×

12．While循环语句的循环体至少执行一次。×

13．Do-while循环可以写成while循环的格式。√

14．For循环是只有可以确定的循环次数时才可使用，否则不能用for循环。×

15．只有for循环的循环体可以是空语句，其他种循环的循环体不能用空语句。×

16．当循环体为空语句时，将说明该循环不作任何工作，只起延时作用。×

17．循环是可以嵌套的，一个循环体内可以包含另一种循环语句。√

18．在多重循环中，内重循环的循环变量应用的次数比外重的多。√

19．Break语句可以出现在各种循环体中。√

20．continue语句只能出现在循环体中。√

三、   分析下列程序的输出结果。

1.

#include<iostream.h>

#define M 1.5

#define A(a) M*a

void main()

{

int x(5),y(6);

cout<<A(x+y)<<endl;

}

13.5

2.

#include<iostream.h>

#define MAX(a,b) (a)>(b)?(a):(b)

void main()

{

int m(1),n(2),p(0),q;

q=MAX(n,n+p)*10;

cout<<q<<endl;

}

20

3.

#include<iostream.h>

#include”f1.cpp”

void main()

{

int a(5),b;

b=f1(a);

cout<<b<<endl;

}

f1.cpp文件内容如下：

#define M(m) m*m

f1(int x)

{

int a(3);

return –M(x+a);

}

13

4.

              #include<iostream.h>

void main()

{

int i(0);

while(++i)

{

if(i= =10) break;

if(i%3!=1) continue;

cout<<i<<endl;

}

}

1

4

7

5.

#include<iostream.h>

void main()

{

int i(1);

do{

i++;

cout<<++i<<endl;

if(i= =7) break;

}while(i= =3);

cout<<”Ok!\n”;

}

3

         5

         Ok!

6.

#include<iostream.h>

void main()

{

int i(1),j(2),k(3),a(10);

if(!i)

a- -;

else if (j)

           if(k) a=5;

else

a=6;

a++;

cout<<a<<endl;

if(i<j)

    if(i!=3)

           if(!k)

                  a=1;

           else if(k)

a=5;

a+=2;

cout<<a<<endl;

}

6

7

7.

#include<iostream.h>

void main()

{

int i,j,a[8][8];

* * a=1;

for(i=1;i<8;i++)

{

* *(a+i)=1;

*(*(a+i)+i)=1;

for(j=1;j<i;j++)

    *(*(a+i)+j)= *(*(a+i-1)+j-1)+ *(*(a+i-1)+j);

}

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

{

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

    cout<<""<<*(*(a+i)+j);

cout<<endl;

}

}

7.        1

1  1

1         2  1

1         3  3  1

1         4  6  4  1

1         5  10  10  5  1

1           6  15  20  15  6  1

  1  7  21  35  35  21  7  1

8.

#include<iostream.h>

void main()

{

int x(5);

do{

switch(x%2)

{

case 1:x- -;

       break;

case 0:x++;

       break;

}

x- -;

cout<<x<<endl;

}while(x>0);

}

8.        3

1

    -1

9.

#include<iostream.h>

void main()

{

int a(5),b(6),i(0),j(0);

switch(a)

{

case 5:switch(b)

{

case 5:i++;break;

case 6:j++;break;

default: i++;j++;

}

case 6: i++;

                     j++;

                     break;

default: i++;j++;

}

cout<<i<<”,“<<j<<endl;

}

1,2

10.

#include<iostream.h>

char input[]="SSSWILTECH1\1\11W\1WALLMP1";

void main()

{

int i;

char c;

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

{

switch(c)

{

case 'a':cout<<'i';

                  continue;

case'1':break;

case 1:while((c=input[++i])!='\1'&&c!='\0');

case 9:cout<<c;

case 'E':

case 'L':continue;

default :cout<<c; continue;

}

cout<<' ';

}

cout<<endl;

}

SWITCH⊙WAMP

四、按下列要求编程，并上机调试。

１．  求100之内的自然数中奇数之和。

２．  求100之内的自然数中被13整除的最大数。

３．  求输入两个正整数的最大公约数和最小公倍数。

４．  求下列分数序列的前15项之和。

        2/1，3/2，5/3，8/5，13/8，21/13，. . .

５．  求∑i！(i=1,. . .,10)(即求1！+2！+3！+4！+5！+6！+7！+8！+9！+10！之和)

６．  求出1～1000之间的完全平方数。所谓完全平方数是指能够表示成为另一个证书的平方的整数。要求每行输出8个数。

７．  输入4个int型数，按其大小顺序输出。

８．  有一函数如下所示：

x       (x<1) Y=   x+5     (1≤x<10)       x-5     (x≥10)

 

 

 

 

已知x值时，输出y值。

９．  求一元二次方程ax²+bx+c=0的解。

讨论下述情况：

（1）b²-4ac=0,有两个相等实根；

（2）b²-4ac>0,有两个不等实根；

(3) b²-4ac<0,有两个共轭复根；

（4）a=0,不是二次方程。

10．编程输出如下图案。

                 *

                      *  *  *

                   *  *  *  *  *

                *  *  *  *  *  *  *

             *  *  *  *  *  *  *  *  *

                *  *  *  *  *  *  *

                   *  *  *  *  *

                      *  *  *

                         *

 

 

第四章　习题

一、             选择填空

1.       当一个函数无返回值时，定义它时函数的类型应是（  ）

A.  void;   B. 任意;     C . int;    D. 无;

2.       在函数说明时，下列（  ）项是不必要的。

A.函数的类型;       B.函数参数类型和名次;       C .函数名字;  D.返回值表达式;

3.       在函数的返回值类型与返回值表达式的类型的描述中，（  ）是错误的。

A.      函数的返回值的类型是定义函数时确定的；

B.      函数的返回值的类型就是返回值表达式的类型;

C.      函数的返回值表达式的类型与函数返回值类型不同时，表达示类型应转换成函数返回值类型；

D.     函数的返回值类型决定了返回值表达式的类型。

4.       在一个被调用函数中，关于return语句使用的描述，（  ）是错误的。

A.      被调用函数中可以不用 return语句;

B.      被调用函数中可以使用多个return语句;

C.      被调用函数中，如果有返回值，就一定要有return语句;

D.     被调用函数中，一个return语句可返回多个值给调用函数。

5.       下列（  ）是引用调用

A.      形参是指针，实参是地址值；

B.      形参和实参都是变量;

C.      形参是数组名，实参是数组名；

D.     形参是引用，实参是变量。

6.       在传值调用中，要求（  ）。

A.      形参和实参类型任意，个数相等;

B.      形参和实参类型都完全一致，个数相等;

C.      形参和实参对应的类型一致，个数相等;

D.     形参和实参对应的类型一致，个数任意。

7.       在C++中，关于下列设置参数默认的描述中，（  ）是正确的。

A.      不允许设置参数的默认值;

B.      设置参数默认值只能在定义函数时设置；

C.      设置参数默认值时，应该是先设置右边的再设置左边的；

D.     设置参数默认值时，应该全部参数都设置；

8.       重载函数在调用时选择的依据中，（  ）是错误的。

A.参数个数;    B.参数的类型;       C .函数名字;  D.函数的类型;

9.        下列的标识符中，（  ）是文件级作用域的。

A.函数形参;    B.语句标号;   C .外部静态类标识符；D.自动类标识符。

10.   有一个int 型变量，在程序中使用频度很高，最好定义为(  )。

A.register;              B.auto;           C .extern;              D.static;

11.   下列标识符中，（  ）不是局部变量。

A.register类;   B.外部static类;     C .auto类;      D.函数形参;

12.   下列存储类标识符中，（  ）的可见性与存在性不一值。

A.      外部类； B.自动类;       C .内部静态类；D.寄存器类。

13.   下列存储类标识符中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（）合适。

A.内联函数;      B.重载函数;   C .递归调用；D.嵌套调用。

14.   采用函数重载的目的在于（  ）。

A.实现共享;B.减少空间；C .提高速度；D.使用方便，提高可读性。

15.   在将两个字符串连接起来组成一个字符串时，选用（  ）函数。

B.      A.strlen();B.strcpy();C .strcat();D.strcmp.

二、判断下列描述的正确性，对者划√，错者划×。

１．    在C++中，定义函数时必须给出函数的类型√

２．    在C++中，说明函数时要用函数原型，即定义函数时的函数头部分。√

３．    在C++中，所有函数在调用前都要说明。×

４．    如果一个函数没有返回值，定义时需用void说明。√

５．    在C++中，传址调用将被引用调用所代替。×

６．    使用内联函数是以牺牲增大空间开销为代价的。√

７．    返回值类型、参数个数和类型都相同的函数也可以重载。×

８．    在设置了参数默认值后，调用函数的对应实参就必须省略。×

９．    计算函数参数顺序引起的二义性完全是由不同的编译系统决定的。√

１０．     For循环中，循环变量的作用域是该循环的循环体内。√

１１．     语句标号的作用域是定义该语句标号的文件内。×

１２．     函数形参的作用域是该函数的函数体。√

１３．     定义外部变量时，不用存储类说明符extern, 而说明外部变量时用它。√

１４．     内部静态类变量与自动类变量作用域相同，但是生存期不同。√

１５．     静态生存期的标识符的寿命是短的，而动态生存期的标识符的寿命是长的。×

１６．     重新定义的标识符在定义它的区域内是可见的，而与其同名的原标识符在此区域内是不可见的。但是，它是存在的。√

１７．     静态类标识符在它的作用域之外是不存在的。×

１８．     所有的函数在定义它的程序中都是可见的。×

１９．     编译系统所提供的系统函数都被定义在他所对应的头文件中。√

２０．     调用系统函数时，要先将该系统函数的原型说明所在的头文件包含进去。√

三、分析下列程序的输出结果。

1.#include<iostream.h>

#define N 5

void fun();

void main()

{

for (int i(1);i<N;i++)

fun();

}

void fun ()

{

static int a;

int b(2);

cout<<(a+=3,a+b)<<endl;

}

1．    5

8

11

14

2. #include<iostream.h>

int add(int a,int b);

void main()

{

extern int x,y;

cout<<add(x,y)<<endl;

}

int x(20),y(5);

int add(int a,int b)

{

int s=a+b;

return s;

}

25

3.#include<iostream.h>

void f(int j);

void main()

{

for(int i(1);i<=4;i++)

f(i);

}

void f(int j)

{

static int a(10);

int b(1);

b++;

cout<<a<<”+”<<b<<”+”<<j<<”=”<<a+b+j<<endl;

a+=10;

}

2．    10+2+1=13

20+2+2=24

30+2+3=35

40+2+4=46

4.#include<iostream.h>

void f(int n)

{

int x(5);

static int y(10);

if(n>0)

{

++x;

++y;

cout<<x<<”,”<<y<<endl;

}

}

void main()

{

int m(1);

f(m);

}

6,11

5.#include<iostream.h>

int fac(int a);

void main()

{

int s(0);

for(int i(1);i<=5;i++)

       s+=fac(i);

cout<<”5!+4!+3!+2!+1!=”<<s<<endl;

}

int fac(int a)

{

static int b=1;

b*=a;

return b;

}

5!+4!+3!+2!+1!=153

6.#include<iostream.h>

void fun(int ,int , int *);

void main()

{

int x,y,z;

fun(5,6,&x);

fun(7,x,&y);

fun(x,y,&z);

cout<<x<<”,”<<y<<”,”<<z<<endl;

}

void fun(int a,int b,int *c)

{

b+=a;

*c=b-a;

}

6,6,6

7.#include<iostream.h>

int add(int x, int y=8);

void main()

{

int a(5);

cout<<”sum1=”<<add(a)<<endl;

cout<<”sum2=”<<add(a,add(a))<<endl;

cout<<”sum3=”<<add(a,add(a,add(a)))<<endl;

}

int add(int x,int y)

{

    return x+y;

}

sum1=13

sum2=18

sum3=23

8.#include<iostream.h>

#define N 6

int f1(int a);

void main()

{

int a(N);

cout<<f1(a)<<endl;

}

int f1(int a)

{

    return(a= =0)?1:a*f1(a-1);

}

720

9.#include<iostream.h>

void swap(int &,int &);

void main()

{

int a(5),b(8);

cout<<”a=”<<a<<”,“<<”b=”<<b<<endl;

swap(a,b);

cout<<”a=”<<a<<”,“<<”b=”<<b<<endl;

}

void swap(int &x,int &y)

{

int temp;

temp=x;

x=y;

y=temp;

}

a=5,b=8

a=8,b=5

10.#include<iostream.h>

int &f1(int n,int s[])

{

int &m=s[n];

return m;

}

void main()

{

int s[]={5,4,3,2,1,0};

f1(3,s)=10;

cout<<f1(3,s)<<endl;

}

10

11. #include<iostream.h>

void print(int),print(char),print(char *);

void main()

{

int u(1998);

print(‘u’);

print(u);

print(“abcd”);

}

void print(char x)

{

    cout<<x<<endl;

}

void print(char *x)

{

    cout<<x<<endl;

}

void print(int x)

{

    cout<<x<<endl;

}

u

1998

abcd

12.#include<iostream.h>

void ff(int),ff(double);

void main()

{

float a(88.18);

ff(a);

char b(‘a’);

ff(b);

}

void ff(int x)

{

    cout<<”ff(int):”<<x<<endl;

}

void ff(double x)

{

    cout<<”ff(double):”<<x<<endl;

}

ff(double):88.18

ff(int):97

四、             按下列要求编程，并上机验证。

１．       从键盘上输入15浮点数，求出其和几平均值。要求写出求和平均值的函数。

２．       从键盘上输入10个int型数，去掉重复的。降其剩余的由大到小排序输出。

３．        给定某个年、月、日的值，例如，1998年4月7日。计算出这一天是该年的第几天。要求写出计算润年的函数和计算日期的函数。

４．       写出一个函数，使从键盘上输入的一个字符串反序存放，并在主函数中输入和输出该字符串。

５．  写出一个函数，要求将输入的十六进制数转换成十进制数。要求函数调用时，使用指针作函数形参。

６．   编写两个函数：一个是将一个5位 int型数转换成为每两个数字间加一个空格的空字符串；另一个是求出转换后的字符串的长度。由主函数输入int型数，并输出转换后的字符串和长度。

７．   输入5个学生4门功课的成绩，然后求出：

   A.每个学生的总分；  B.  每门课程的平均分； C. 输出总分最高的学生的姓名和总分数。

８．   使用递归调用方法将一个n位整数转换成字符串。

９．   使用函数重载的方法定义两个重名函数，分别求出int型数的两个点间距离和浮点数的两点间距离。

１０． 已知二维字符数组s[][5]={“abcd”,”efgh”,”ijkl”,”mnop”};使用字符串处理函数，将该数组的4个字符串连接起来，组成一个字符串：abcdefghijklmnop。

１１． 编程求下式的值：n1+n2+n3+n4+…+n10，其中n=1,2,3。编写函数时，设置参数n的默认值为2。

１２． 编一个程序验证哥德巴赫猜想：任何一个充分大的偶数（大于等于6）总可以表示成两个素数之和。要求编一个求素数prime()函数，它有一个int型参数，当参数值为素数时返回1，否则返回0。