c++习题.docx

c++习题.docx

《c++习题.docx》由会员分享，可在线阅读，更多相关《c++习题.docx（19页珍藏版）》请在冰豆网上搜索。

c++习题

1．intfun（inti,intj）

{ints;

i=i+2;

j=j-1;

s=i+j;

returns;

}

voidmain（）

{inti=4,j=5;

cout<

}程序运行结果为：

答案：

4510。

i=4;j=5;

在fun（i,j）中，i=i+2=6;j=j-1=4s=i+j=10,因此结果为10。

2.#include

voidmain（）

 {      intx,y;

        x=5;y=6;

         cout<<”x+y=”<

         cout<<”x*y=”<

   }

程序运行结果为：

答案：

x+y=11,x*y=30

3.#include

voidmain（） 

{ 

   for（inti=1,s=0;i<=7;i++）

        {

            if（i%2==0||i%3==0）continue;

            cout<

            s+=i;

cout<

        }

}

程序运行结果为：

答案：

1s=1

5s=6

7s=13

4．#include

voidmain（）

{inty=1,x,*p,a[]={2,4,6,8,10};

p=&a[1];

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

y+=*（p+x）;

cout<

}程序运行结果为：

答案：

19。

#include//包含输入输出头文件，cout就在这个文件里。

voidmain（）//主函数

{inty=1,x,*p,a[]={2,4,6,8,10};//定义变量

p=&a[1];//将a[1]的地址存入指针p

for（x=0;x<3;x++）//定义for循环，循环3次

y+=*（p+x）;//第一次循环*（p+x）为a[1]的值也就是4，第二次循环

*（p+x）为a[2]的值也就是6，第三次循环*（p+x）为

a[3]的值也就是8，y本身的值为1，所以经过循环后

y=1+4+6+8=19。

cout<

}

5．#include

classA{inta;

public:

A（intaa=0）{a=aa;}

~A（）{cout<<"DestructorA!

"<

};

classB:

publicA{

intb;

public:

B（intaa=0,intbb=0）:

A（aa）{b=bb;}

~B（）{cout<<"DestructorB!

"<

};

voidmain（）

{Bx（5）,y（6,7）;

}

程序运行结果为：

答案：

DestructorB!

7

DestructorA!

6

DestructorB!

0

DestructorA!

5

#include//包含输入输出头文件，cout就在这个文件里。

classA{inta;//类的声明和变量a的声明

public:

A（intaa=0）{a=aa;}//构造函数的定义

~A（）{cout<<"DestructorA!

"<

};

classB:

publicA{//使用继承定义类B

intb;

public:

B（intaa=0,intbb=0）:

A（aa）{b=bb;}//构造函数B复用类A的构造函

数，并通过成员初始化将值传送

到A的构造函数

~B（）{cout<<"DestructorB!

"<

};

voidmain（）//主函数

{Bx（5）,y（6,7）;//创建x、y对象并调用构造函数初始化

}

注意：

在同一函数中定义了两个对象的时候，先执行先构造的对象的构造函数，再执行后构造的对象的构造函数；函数结束时，先执行后构造的对象的析构函数，再执行先构造的对象的析构函数。

6.#include 

intf1（intx,inty）

{ 

x=x+y;y=x+y; 

cout<<”x=”<

returnx+y;

}

voidmain（）

{ 

intx=5,y=8; 

intz=f1（x,y）; 

cout<<”x=”<

cout<<”,z=”<

}

程序运行结果为：

答案：

x=13,y=21

x=5,y=8,z=34

#include //包含输入输出头文件，cout就在这个文件里。

intf1（intx,inty）//子函数定义

{ 

x=x+y;y=x+y; //x，y变量赋值（x,y为子函数局部变量）

cout<<”x=”<

returnx+y;//返回x+y

}

voidmain（）//主函数

{ 

intx=5,y=8; //初始化变量x,y（x,y主为局部变量）

intz=f1（x,y）; //调用子函数

cout<<”x=”<

cout<<”,z=”<

}

7．#include

classBox

{private:

inta,b,c;

public:

Box（inta1,intb1,intc1）

{a=a1;

b=b1;

c=c1;

}

intvolum（）

{intv;

v=a*b*c;

returnv;

}

};

voidmain（）

{Boxbox（4,5,6）;

cout<<"体积为:

"<

}

程序运行结果为：

答案：

体积为：

120。

#include//包含输入输出头文件，cout就在这个文件里。

classBox//类的声明

{private:

//定义私有变量

inta,b,c;

public:

//构造函数的定义

Box（inta1,intb1,intc1）

{a=a1;

b=b1;

c=c1;

}

intvolum（）//共有成员函数定义

{intv;

v=a*b*c;

returnv;

}

};

voidmain（）//主函数

{Boxbox（4,5,6）;//创建box对象并调用构造函数初始化

cout<<"体积为"<

}

8.#include 

#definePI3.14159 

constintR=10 

voidmain（） 

{ 

    doublep,s;

        p=2*R*PI;

      s=PI*R*R;

        cout<<”p=”<

    cout<<”s=”<

}程序运行结果为：

答案：

p=62.8318

s=314.159

p=2*R*PI=2*10*3.14159=62.8318

s=PI*R*R=3.15159*10*10=314.159

9.#include 

classA{ 

   inta,b; 

public:

 A（）{ a=b=0; } 

   A（intaa,intbb）

{ 

 a=aa;b=bb; 

 cout<

  }

}; 

voidmain（）

{   A x,y（2,3）,z（4,5）; 

}程序运行结果为：

答案：

23

45

#include //包含输入输出头文件，cout就在这个文件里。

classA{ //定义类A

   inta,b; //定义两个整型变量a,b

public:

 A（）{ a=b=0; } //构造函数的声明

   A（intaa,intbb）//重载构造函数的声明

{ 

 a=aa;b=bb; //变量a,b的赋值

 cout<

  }

}; 

voidmain（）//主函数

{   A x,y（2,3）,z（4,5）; //创建对象并调用构造函数初始化

}

10．#include

#include

voidmain（）

{inti,j,max;

charch;

charstr[]="1234567";

for（i=0,j=strlen（str）-1;i

{ch=str[i];

str[i]=str[j];

str[j]=ch;

}

cout<

}

程序运行结果为：

答案：

7654321

#include//包含输入输出头文件，cout就在这个文件里。

#include//包含字符串处理头文件

voidmain（）//主函数

{inti,j,max;//声明三个整型变量

charch;//声明一个字符变量

charstr[]="1234567";//定义字符串str

for（i=0,j=strlen（str）-1;i

{ch=str[i];//将str[i]存入ch;

str[i]=str[j];//将str[j]存入str[i];

str[j]=ch;//将ch存回str[j]

}

cout<

}

1．在一个一维整型数组中找出其中最大的数及其下标。

程序中共有4条错误语句，请改正错误。

#defineN10

floatfun（int*a,int*b,intn）

{ int*c,max=*a;

 for（c=a+1;c

  if（*c>max）

   {max=*c;

    b=c-a;}

 returnmax;

}

main（）

{ inta[N],i,max,p=0;

 printf（"pleaseenter10integers:

"）;

 for（i=0;i

 scanf（"%d",a[i]）;

 max=fun（a,p,N）;

 printf（"max=%d,position=%d",max,p）;

}

答案：

1intfun（int*a,int*b,intn）

   2*b=c-a;}

    3scanf（"%d",&a[i]）;

    4max=fun（a,&p,N）;

1.Max定义是一个整型变量，因此fun所返回的数据类型也必须是int

2.b是一个指针变量，它只能存储地址，而b所指向的地址存的是最大的数（max）的下标，所以要用*b

3.scanf的格式，后边应是地址，因此要用&a[i]

4.因为p对应的是fun里面的*b,是一个指针变量，因此要存入地址&p

2．函数fun的功能是：

计算正整数num的各位上的数字之积。

例如，输入252，则输出应该是20。

程序中共有4条错误语句，请改正错误。

longfun（longnum）

{

 longk;

 do

 {

  k*=num%10;

  num\=10;

  }while（num）;

  returnk;

}

main（）

{

 longn;

 printf（"\nPleaseenteranumber:

"）;

 scanf（"%ld",n）;

 printf（"\n%ld\n",fun（longn））;

}

答案：

（1）longk=1;变量没有初始化，无法做乘法

（2）num/=10;或num=num/10;除号错误

 （3）scanf（"%ld",&n）;scanf函数中的“格式控制”后面应当是变量地址，而不是变量名。

 （4）printf（"\n%ld\n",fun（n））;不需要再输入变量数据类型。

3．用起泡法对10个整数从小到大排序。

程序中共有3条错误语句，请改正错误。

课本140页有气泡发的原理和程序，大家可以参考

voidsort（intx,intn）

{ inti,j,k,t;

 for（i=0;i

for（j=0;j

    if（x[i]>x[i+1]）

      {t=x[j];x[j]=x[j+1];x[j+1]=t;}

}

main（）

{ inti,n,a[100];

 printf（"pleaseinputthelengthofthearray:

"）;

 scanf（"%d",&n）;

 for（i=0;i

 scanf（"%d",&a[i]）;

 sort（a,n）;

 printf（"outputthesortedarray:

"）;

 for（i=0;i<=n-1;i++）

 printf（"%5d",a[i]）;

 printf（""）;

}

答案：

1voidsort（intx[],intn）

2for（j=0;jj;j++）或for（j=0;jj;j++）

3if（x[j]>x[j+1]）或if（x[j+1]

1.x是一个数组，因此定义形参时要用数组形式

2.起泡法要让j从第1个数循环到第n-1-i个数，第一个数的下标是0，第n-1-i个数下标是n-2-i，因此要j

3.i是最外层的循环数，而比较的应该是内层循环的两个数

4．函数fun的功能是：

求出两个非零正整数的最大公约数，并作为函数值返回。

例如，若给num1和num2分别输入49和21，则输出的最大公约数为7。

程序中共有4条错误语句，请改正错误。

intfun（inta,intb）

{

 intr,t;

 if（a

{

 t=a;

 b=a;//如果a

 a=t;//如果a

}

r=a%b;

while（r!

=0）

{

 a=b;

 b=r;

 r=a/b;}//要a除以b后的余数

 returna;//应该返回b的值

}

main（）

{

 intnum1,num2,a;

 scanf（"%d%d",&num1,&num2）;

 a=fun（num1,num2）;

 printf（"themaximumcommondivisoris%d\n\n",a）;

}

答案：

（1）a=b;变量值传递错误

（2）b=t;变量值传递错误

（3）r=a%b;}取整数后的余数而不是商

（4）returnb;或return（b）;或return（b）;b中最终存放的是最最大公约数。

5．以下程序的功能是求如下表达式：

 S=1+1/（1+2）+1/（1+2+3）+1/（1+2+3+4）…程序中共有4条错误语句，请改正错误。

#include

main（）

{ intn;

 floatfun（）;

 printf（"Pleaseinputanumber:

"）;

 printf（"%d",n）;                           

printf（"%10.6f",fun（n））;

}

fun（intn）

{ inti,j,t;

 floats;

 s=0;

 for（i=1;i<=n;i++）;

{ t=0;

 for（j=1;j<=i;j++）

 t=t+j;

 s=s+1/t;

 }

returns;

}

答案：

1 scanf（"%d",&n）;

2floatfun（intn）

3for（i=1;i<=n;i++）或for（i=1;n>=i;i++）或for（i=1;ii;i++）

4s+=1.0/t或s=s+1.0/（float）t;或s=s+1.0/t;或s+=1.0/（float）t

1.输入应为scanf,输出时printf

2.Fun声明时是函数类型为浮点型数，因此要用floatfun（intn）

3.For语句这里不能加分号，否则大括号里的内容将不再执行。

4.t是一个整型变量，要将它转换为浮点型

6．fun函数的功能是：

先从键盘上输入一个3行3列矩阵的各个元素的值，然后输出主对角线上的元素之和sum。

请改正程序中的4个错误，使它能得出正确的结果。

#include

intfun（）

{

 inta[3][3],sum;

 inti,j;

 a=0;

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

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

    scanf（"%d",a[i][j]）;

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

   sum=sum+a[i][j];

 printf（"sum=%f\n",sum）;

}

main（）

{

 fun（）;

}

答案：

（1）sum=0;变量没有初始化。

（2） scanf（"%d",&a[i][j]）;scanf函数中的“格式控制”后面应当是变量地址，而不是变量名。

   （3） sum=sum+a[i][i];或sum+=a[i][i];取对角线的值

   （4） printf（"sum=%d\n",sum）;输出应为整数而%f为浮点数。

1.随机产生10个数存入一维数组a中，求这10数中的最大数并输出。

答案：

#include//包含输入、输出头文件

#include//包含ctime头文件，已使用后面的time（0）函数

usingnamespacestd;//表明命名空间std中的所有成员都能直接引用

intmain（）//主函数

{

inta[10],max;//定义一个整形数组和变量

srand（time（0））;//随机数发生器的初始化函数，time（0）返回当前时间，使用时间来初始化，避免随机数重复

for（i=0;i<10;i++）//循环

a[i]=rand（）%100;//产生10个小于10的随机数

cout<<"小于100的10个随机数：

"<

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

{

cout<

}//显示10个随机数

max=a[0];//初始化max

for（inti=1;i<10;i++）

{

if（max

}//寻找最大数

cout<<”最大数是:

”<

return0;//返回0

}

2.编写程序输出以下图形：

*

***

*****

*******

*********

答案：

#include//包含输入、输出头文件

intmain（）//主函数

{inti,k,j;//声明变量

for（i=1;i<=5;i++）//最外层的循环

{for（j=0;j<=6-i;j++）//中间层的循环

cout<<"";//输出空格

for（k=0;k<2*i-1;k++）//内层的循环

cout<<"*";//输出星号

cout<

}

return0；//返回0

}

3.求出10至100之内能同时被2、3、7整除的整数，并输出。

答案：

#include//包含输入、输出头文件

usingnamespacestd;//表明命名空间std中的所有成员都能直接引用

voidmain（）//主函数

{

for（inti=10;i<100;i++）//定义循环

{

if（（（i%2）==0）&&（（i%3）==0）&&（（i%7）==0））

//寻找能被2,3,7，同时整除的数

{

cout<

}

}

}

4．定义一个矩形类Rectangle，包括数据成员：

宽（width）和长（length）；

要求：

（1）编写成员函数计算矩形周长；

（2）编写成员函数计算矩形面积；

（3）编写成员函数改变矩形大小，该成员函数原型为：

voidSetSize（doublenewwidth,doublenewlength）；

答案：

classRectangle//定义类

{

private:

doublewidth,length;//声明私有变量

public:

//声明共有成员

doubleGetPerimeter（）//计算周长成员函数定义

{

return（（width+length）*2）;

}

doubleGetArea（）//计算面积成员函数定义

{

return（width*length）;

}

voidSetSiz