C++编程练习题大全（带答案）南京廖华答案网

C++编程练习题大全（带答案）下载本文

文章发布时间 : 2026/2/28 7:45:23星期六

一、简单问题：

5. 编程计算： 1!+2!+3!+…+20!，并将结果输出.输出格式： 1!+2!+3!+…+20!= 表达式的值 package moreEasy; public class The5th {

public static void main(String[] args) { long sum=0;

for(int i=1;i<=20;i++){ long r=1;

for(int j=1;j<=i;j++){ r*=j; }

sum=sum+r;

//System.out.print(\ if(i<20)

System.out.print(i+\ else

System.out.print(i+\ } } }

1. 编程求下列式子的值，

ｙ＝1-1/2+1/3-1/4+…+1/99-1/100

并将结果输出，格式为: 1-1/2+1/3-1/4+…+1/99-1/100 = 表达式的值 public class Porg {

public static void main(String[] args) { double sum=0;

for(double i=1;i<=100;i++) {

sum=sum+Math.pow(-1, i-1)*(1/i); }

System.out.print(\1/4+…+1/99-1/100=\ } }

2. 请编程实现：由键盘输入的任意一组字符，统计其中大写字母的个数m和小写字母的个数n，并输出m、n中的较大者。

import java.util.Scanner; public class Prog2 {

public static void main(String[] args) { int m=0,n=0;

Scanner cin=new Scanner(System.in);

409--1

}

String str=cin.nextLine();

for(int i=0;i

if(str.charAt(i)>'A'&&str.charAt(i)<='Z') m++; else n++; }

if(m>n) {

System.out.println(m); } else

System.out.println(n);

3. 编程，求全部水仙花数。所谓水仙花数是指一个三位数，其各位数字立方的和等于该数。如：153 = 1

+ 5+ 3。

public class Prog3 {

public static void main(String[] args) { int a,b,c; for(a=1;a<=9;a++) {

for(b=0;b<=9;b++) {

for(c=0;c<=9;c++) {

if(a*100+b*10+c==a*a*a+b*b*b+c*c*c) System.out.println(a*100+b*10+c); } } } }

4. 请编制程序判断输入的正整数是否既是5又是7的整倍数。若是，则输出yes；否则输出no。 import java.util.Scanner; public class Prog4 {

public static void main(String[] args) {

Scanner cin=new Scanner(System.in); int i=cin.nextInt(); if( i%5==0&&i%7==0)

System.out.print(\

409--2

} }

else

System.out.print(\

5. 请编程实现：对于给定的一个百分制成绩，输出相应的五分制成绩。设：90分以上为‘A’，80—89分为‘B’，70—79分为‘C’，60—69分为‘D’，60分以下为‘E’ 。 import java.util.Scanner; public class Prog5 {

public static void main(String[] args) { Scanner cin=new Scanner(System.in); int m=cin.nextInt(); if(m>=60&&m<=69)

System.out.print(\ else

if(m>=70&&m<=79)

System.out.print(\ else

if(m>=80&&m<=89)

System.out.print(\ else

if(m>=90)

System.out.print(\ else

System.out.print(\ } }

6. 输入一行字符，将其中的字母变成其后续的第3个字母，输出。例：a→d，x → a；y → b；编程实现。

import java.util.Scanner; public class Prog6 {

public static void main(String[] args) { char[] zimu=new

char[]{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','a','b','c'}; Scanner cin=new Scanner(System.in); String str=cin.nextLine();

for(int j=0;j

for(int i=0;i<29;i++) {

if(str.charAt(j)==zimu[i]) {

System.out.println(zimu[i+3]);

409--3

break; } } }

7. 编写程序，输入任意一个1~7之间的整数，将他们转换成对应的英文单词. 例如：1转换成Monday，7转换成Sunday.

import java.util.Scanner; public class Prog7 {

public static void main(String[] args) { System.out.print(\请输入任意一个1~7之间的整数\\n\ Scanner cin=new Scanner(System.in); int m=cin.nextInt(); if(m==1)

System.out.print(\ else

if(m==2)

System.out.print(\ else

if(m==3)

System.out.print(\ else

if(m==4)

System.out.print(\ else

if(m==5)

System.out.print(\ else

if(m==6)

System.out.print(\ else

System.out.print(\ }

}

8. 输入三角形的三边a, b, c，判断能否构成三角形. 若能，计算面积. import java.util.Scanner; public class Prog8 {

public static void main(String[] args) { System.out.print(\请输入三个整数\\n\ Scanner cin=new Scanner(System.in); int a=cin.nextInt(); int b=cin.nextInt(); int c=cin.nextInt();

if(a+b

409--4

}

{

System.out.print(\不能构成三角形\\n\ } else {

int l=a+b+c;

System.out.print(l); } }

9. 编程序，输入a,b,c，求方程 ax+bx+c=0 的解。 import java.util.Scanner; public class Prog9 {

public static void main(String[] args) {

System.out.print(\请输入三个整数\\n\Scanner cin=new Scanner(System.in); int a=cin.nextInt(); int b=cin.nextInt(); int c=cin.nextInt(); if(a==0) {

System.out.println(-c/b); }

else if(b*b-4*a*c>=0) {

double x1=(-b+Math.pow(1/2, b*b-4*a*c))/(2*a); double x2=(-b-Math.pow(1/2, b*b-4*a*c))/(2*a); System.out.println(x1); System.out.print(x2); }

else System.out.print(\无解\}

}

10.计算出前20项 fibonacci 数列, 要求一行打印5个数.

一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔都不死，那么一年以后可以繁殖多少对兔子？我们不妨拿新出生的一对小兔子分析一下：第一个月小兔子没有繁殖能力，所以还是一对; 两个月后，生下一对小兔总数共有两对;

409--5

三个月以后，老兔子又生下一对，因为小兔子还没有繁殖能力，所以一共是三对; ?? 依次类推可以列出下表：经过月数 0 1 2 3 4 5 6 7 8 9 10 11 12 幼仔对数 0 1 1 2 3 5 8 13 21 34 55 89 144 成兔对数 1 1 2 3 5 8 13 21 34 55 89 144 233 总体对数 1 2 3 5 8 13 21 34 55 89 144 233 377 import java.util.Scanner;

public class Prog10 {

public static void main(String[] args) { Scanner cin=new Scanner(System.in); int n=cin.nextInt(); int a=0,b=1,c=1;

if(n==1){System.out.println(a ); System.out.println(b ); System.out.println(c );} else {

for(int i=2;i<=n;i++) { a=b; b=c; c=a+b; }

System.out.println(\幼崽数\成年兔子书\总数\ }

} }

11．输出100~10000之间个位数为3的所有素数。

public class Prog11 {

public static void main(String[] args) { for(int i=103;i<10000;i=i+10) {

boolean flag=true;

409--6

}

for(int j=2;j

if(i%j==0)

{flag=false;break;} }

if(flag==true){System.out.println(i);} }

12. 百钱买百鸡问题：公鸡每只 5 元，母鸡每只 3 元，小鸡 3 只一元，问一百元买一百只鸡有几种买法.

public class Prog12 {

public static void main(String[] args) { int m=0;

for(int a=0;a<100;a++) {

for(int b=0;b<100;b++) {

for(int c=0;c<100;c++)

if(5*a+3*b+1/3*c==100&&a+b+c==100) m++; } } }

System.out.print(\一百元买一百只鸡有\种买法\}

2222

13. 请编制程序要求输入整数a和b，若a+b大于100，则输出a+b百位以上的数字，否则输出两数之和。 import java.util.Scanner; public class Prog13 {

public static void main(String[] args) {

System.out.print(\请输入两个整数\\n\Scanner cin=new Scanner(System.in); int a=cin.nextInt(); int b=cin.nextInt(); if(a*a+b*b>100) {

System.out.print(a*a+b*b); } else

System.out.print(a+b);

409--7

} }

14. 编程实现：对键盘输入的任意一个四位正整数，计算各位数字平方和。

2222

如：2345 ,则：计算2+3+4+5

import java.util.Scanner; public class Prog14 {

public static void main(String[] args) {

System.out.print(\请输入任意一个四位正整数\\n\ int sum=0;

Scanner cin=new Scanner(System.in); int a=cin.nextInt();

sum=(a/1000*a/1000)+((a/100)*(a/100))+((a/100)*(a/100))+((a)*(a));

System.out.print(sum);

} }

15. 有1020个西瓜，第一天卖一半多两个，以后每天卖剩下的一半多两个，问几天以后能卖完，请编程.

public class Prog15 {

public static void main(String[] args) { int m=0,sum=1020; do{

sum=sum/2-2; m++;

}while(sum>=0);

System.out.print(m+\天以后能卖完\

} }

222

16. 编程，输出200以内所有完全平方数C（满足C=A+B）及其个数.

409--8

public class Prog16 {

public static void main(String[] args) { int m=0;

for(int C=1;C<200;C++) {

for(int A=1;A<=200;A++) {

for(int B=1;B<=200;B++) {

if(A*A+B*B==C*C)

{System.out.println(C); A=201; B=201; m++;} } } }

System.out.println(\个数为：\ } }

17. 设Ｎ是一个四位数，它的９倍恰好是其反序数（例如：123的反序数是321），编程，输出所有满足条件的Ｎ。

package easy;

public class The17 {

static long s,M;

public static void main(String[] args) { for(long N=1009;N<=1109;N=N+10){ M=9*N; s=0;

while(M>0){

s=s*10+M; M=M/10; }

409--9

if(N==s)

System.out.println(s); }

}

18. 编程，输出555555的约数中最大的三位数。 package easy;

public class The18th {

public static void main(String[] args) { double a=555555; long b=0;

//long[] yueShu=new long[555555]; for(long i=1;i<=555555;i++){ if(a%i==0&&i>99&&i<1000){ while(i>b){ b=i; } } }

System.out.println(b); } }

19. 编程，输出所有个位数为6且能被31整除的五位数及其个数。 package easy;

public class The19th {

public static void main(String[] args) { for(long i=10006;i<=99996;i=i+10){ if(i1==0){

System.out.println(i); } } } }

20. 编写程序，输入两个整数，和+、-、*、/ 、％之中的任意一个运算符，输出计算结果. package easy;

//import java.util.InputMismatchException; import java.util.Scanner; public class The20th {

static Scanner cin=new Scanner(System.in); public static void main(String[] args) { Scanner cin1=new Scanner(System.in);

409--10

int d1,d2;

String str=new String(\ d1=cin.nextInt(); d2=cin.nextInt();

//System.out.println(d1); //System.out.println(d2); str=cin1.nextLine();

//System.out.println(str);

//System.out.println(str.charAt(0)); switch(str.charAt(0)){ case '+':{

System.out.println(d1+d2); break; }

case '-':{

System.out.println(d1-d2); break; }

case '*':{

System.out.println(d1*d2); break; }

case '/':{

System.out.println(d1/d2); break; } } }

/*static int add(int a,int b){ return a+b; }

static int sub(int a,int b){ return a-b; }

static int multiply(int a,int b){ return a*b; }

static int divide(int a,int b){ return (int)(a/b); }*/

409--11

}

21. 计算：1+1/（1+2）+1/（1+2+3）+…+ 1/（1+2+…+n）, n由键盘输入。 package easy;

import java.util.Scanner; public class The21th {

public static void main(String[] args) { double sum=0,div=0;

Scanner cin=new Scanner(System.in); int n=cin.nextInt(); for(int i=1;i<=n;i++){ div=div+i;

System.out.println(\ sum=sum+1/div; }

System.out.println(sum); } }

22. 编程计算: 1*2*3+3*4*5+…+99*100*101 的值. package easy;

public class The22th {

public static void main(String[] args) { long sum=0;

for(int i=1;i+2<=101;i=i+2){ sum=sum+i*(i+1)*(i+2); }

System.out.println(sum); } }

二、比较简单问题：

1. 编一个函数GCD，求两个无符号整数的最大公约数。主函数输入两个正整数m 和 n, 调用GCD，求出m和n的最大公约数和最小公倍数.并输出。 package moreEasy;

import java.util.Scanner; public class The1th {

public static void main(String[] args) { Scanner cin=new Scanner(System.in); int m=cin.nextInt(); int n=cin.nextInt();

409--12

System.out.println(m+\和\的最大公约数为：\ System.out.println(m+\和\的最小公倍数为：\ }

public static int GCD(int a,int b){ int r=0;

for(int i=1;i<=a&&i<=b;i++){ if(a%i==0&&b%i==0&&r

//System.out.println(r); return r; } }

2. 请编程实现：建立一个4*4的二维整型数组，求对角线元素的和。 package moreEasy;

import java.util.Scanner; public class The2th {

public static void main(String[] args) { int ewsz[][]=new int[4][4];

Scanner cin=new Scanner(System.in); for(int i=0;i

for(int j=0;j

/*for(int i=0;i

for(int j=0;j

System.out.println(\ } } }*/

int sum=0;

for(int i=0;i

System.out.println(sum); } }

3. 写一个判断素数的函数prime，在主函数中输入10个整数，调用prime，输出这１0个整数中的素数的累加和。

package moreEasy;

409--13

import java.util.Scanner; public class The3th {

public static void main(String[] args) { int[] shu=new int[10]; int sum=0;

Scanner cin=new Scanner(System.in); for(int i=0;i

for(int i=0;i

System.out.println(sum); }

public static boolean prime(int a){ //double b=Math.pow(a, 0.5); for(int i=2;i

return true; } }

4．从键盘上输入若干学生的一门课成绩，存入一个数组中，当输入负数时结束输入. 输出最高成绩和最低成绩及相应的序号。 package moreEasy;

import java.util.Scanner; public class The4th {

public static void main(String[] args) { int n,n1=0,max,min;

Scanner cin=new Scanner(System.in); System.out.print(\学生人数\ n=cin.nextInt();

int[] chengJi=new int[n]; for(int i=0;i

chengJi[i]=cin.nextInt(); }

max=chengJi[0]; min=chengJi[0];

for(int j=0;j

409--14

max=chengJi[j]; n=j; }

if(min>chengJi[j]){ min=chengJi[j]; n1=j; } }

System.out.println(\ System.out.println(\ } }

5. 编程计算： 1!+2!+3!+…+20!，并将结果输出.输出格式： 1!+2!+3!+…+20!= 表达式的值 package moreEasy; public class The5th {

public static void main(String[] args) { long sum=0;

for(int i=1;i<=20;i++){ long r=1;

for(int j=1;j<=i;j++){ r*=j; }

sum=sum+r;

//System.out.print(\ if(i<20)

System.out.print(i+\ else

System.out.print(i+\ } } }

6. 有一个３ * 4 的矩阵，编程实现：找出该矩阵中每行元素的最大值，存入一个一维数组中。输出原始矩阵和结果矩阵。

7. 将若干个整数放到一维数组中，找出该数组中的最大值和它的下标。然后将它和数组中的最前面的元素对换。不明白 package moreEasy;

import java.util.Scanner; public class The7th {

public static void main(String[] args) { int[] array=new int[10];

Scanner cin=new Scanner(System.in);

409--15

System.out.print(\数组长度：\ int n=cin.nextInt(); for(int i=0;i

array[i]=cin.nextInt(); }

int min=array[0]; int max=array[0];

//System.out.println(min); //System.out.println(max);

for(int i=0;i

System.out.println(min); System.out.println(max); } }

8. 编写一个函数converse，将一维数组中的数逆序存放，不允许使用辅助数组。主函数输入原始数据，调用converse，实现逆置。并将原数组和逆置后的数组输出 package moreEasy;

import java.util.Scanner; public class The8th {

public static void main(String[] args) { converse(); }

public static void converse(){ int[] ar=new int[10];

Scanner cin=new Scanner(System.in);

for(int i=0;i

for(int j=0;j

System.out.println(\

for(int i=0;i

409--16

}

for(int j=0;j

9. 编写函数，将给定的字符串的大写字母转变成小写字母；其它字符不变。主函数输入一个字符串，调用该函数对其进行转换，分别输出原串和转换之后的串。 package moreEasy;

import java.util.Scanner;

public class The9th { static String str=\

public static void main(String[] args) { String str=\

Scanner cin=new Scanner(System.in); str=cin.nextLine(); zhuanHuan(str); }

public static void zhuanHuan(String str1){ str=str1;

str=str.toLowerCase(); System.out.println(str); } }

10. 编写一个函数，将字符数组a中的全部字符复制到字符数组b中. 不要使用strcpy函数. 主函数输入任意一个字符串，调该函数，复制出另一个字符串。将两个串输出。 package moreEasy;

import java.util.Scanner; public class The10th {

public static void main(String[] args) { Scanner cin=new Scanner(System.in); String str=cin.nextLine();

char[] aa=new char[str.length()]; char[] bb=new char[str.length()]; for(int i=0;i

copy(aa,bb);

for(int i=0;i

409--17

System.out.println(\

for(int i=0;i

public static void copy(char[] a,char[] b){ for(int i=0;i

11. 判断一个N*N的矩阵是否为对称矩阵. 将原矩阵输出，判断结果输出. package moreEasy;

import java.util.Scanner; public class The11th {

public static void main(String[] args) { Scanner cin=new Scanner(System.in); int n=cin.nextInt(); int count=0;

int[][] duiCheng=new int[n][n]; for(int i=0;i

for(int j=0;j

for(int i=0;i

for(int j=0;j

System.out.print(duiCheng[i][j]+\ else

System.out.print(duiCheng[i][j]+\ }

for(int i=0;i

for(int j=0;j

if(count==n*n)

System.out.println(\对称矩阵\ else

System.out.println(\非对称矩阵\ }

409--18

}

12. 给出年、月、日, 计算该日是该年的第几天？ package moreEasy;

import java.util.Scanner; public class The12th {

public static void main(String[] args) { int n=0;

Scanner cin=new Scanner(System.in); int y=cin.nextInt();

System.out.println(\年\ int m=cin.nextInt();

System.out.println(\月\ int d=cin.nextInt();

System.out.println(\日\

if(y%4==0&&y0!=0||y@0==0){ switch(m){ case 1: n=d; break; case 2: n=d+31; break; case 3:

n=d+31+29; break; case 4:

n=d+31+29+31; break; case 5:

n=d+31+29+31+30; break; case 6:

n=d+31+29+31+30+31; break; case 7:

n=d+31+29+31+30+31+30; break; case 8:

n=d+31+29+31+30+31+30+31; break; case 9:

n=d+31+29+31+30+31+30+31+31; break; case 10:

n=d+31+29+31+30+31+30+31+31+30; break;

409--19

case 11:

n=d+31+29+31+30+31+30+31+31+30+31; break; case 12:

n=d+31+29+31+30+31+30+31+31+30+31+30; break; } switch(m){ case 1: n=d; break; case 2: n=d+31; break; case 3:

n=d+31+28; break; case 4:

n=d+31+28+31; break; case 5:

n=d+31+28+31+30; break; case 6:

n=d+31+28+31+30+31; break; case 7:

n=d+31+28+31+30+31+30; break; case 8:

n=d+31+28+31+30+31+30+31; break; case 9:

n=d+31+28+31+30+31+30+31+31; break; case 10:

n=d+31+28+31+30+31+30+31+31+30; break; case 11:

n=d+31+28+31+30+31+30+31+31+30+31; break; case 12:

n=d+31+28+31+30+31+30+31+31+30+31+30; break;

409--20

} else{

} }

System.out.println(n); } }

13. 编写一个子函数fun ，求两个矩阵的乘积矩阵；主程序中输入两个矩阵的阶数和元素值，调用fun，求出乘积矩阵，在主程序中将原矩阵和乘积矩阵输出。 package moreEasy;

import java.util.Scanner;

public class The13th {

public static void main(String[] args) { Scanner cin=new Scanner(System.in); Scanner cin1=new Scanner(System.in); System.out.print(\阶数：\ int n1=cin.nextInt(); //int n2=cin.nextInt(); int[][] aa=new int[n1][n1]; int[][] bb=new int[n1][n1]; System.out.println(\输入第一个矩阵\ for(int i=0;i

409--21

public static void fun(int[][] a,int[][] b){ for(int i=0;i

14. 打印出如图所示的杨辉三角，要求打印出n行，n由键盘输入.

1 1 1 1 2 1

1 3 3 1 … …

package moreEasy;

import java.util.Scanner; //有毛病，未解决

public class The14th {

/**

* @param args */

public static void main(String[] args) { Scanner cin=new Scanner(System.in); int n=cin.nextInt();

int[][] yhsj=new int[n][n]; yhsj[0][0]=1;

for(int i=1;i

for(int j=1;j

yhsj[i][j]=yhsj[i-1][j-1]+yhsj[i-1][j]; }

yhsj[i][yhsj[i].length-1]=1; }

for(int i=0;i

System.out.print(yhsj[i][j]+\ if(j==yhsj[i].length-1) System.out.println(\ } }

409--22

}

15. 编写一个程序，将两个字符串连接起来. 不要使用strcat函数； package moreEasy; //有毛病，未解决

public class The15th {

public static void main(String[] args) { String str=\第一个字符串\ String str1=\第二个字符串\

char[] a=new char[str.length()+str1.length()]; for(int i=0;i

for(int i=str.length()-1;i

str=str.valueOf(a); System.out.println(str); } }

C++的特点：1.支持抽象数据类型

2.多态性，一个接口，多重算法，支持早期联编和滞后联编 3.继承性，保证了代码复用，支持分类的概念

一个c++程序由一个或多个函数构成，并且在这些函数中只有一个主函数main，它是程序执行的入口。

C++程序严格区别字母的大小写。

第2章基本数据类型、运算符与表达式

【内容提要】数据类型变量与常量运算符与表达式简单输入与输出【重点与难点】 2.1 数据类型

在C++程序里，每个名字都有一个与之相关联的类型，这个类型决定了可以对这个名字所指代的实体应用什么操作，并决定这些操作将如何做出解释。

409--23

布尔型 bool 整型 int

基本数据类型字符型 char 单精度型 float 浮点型双精度型 double 空类型 void 数据类型指针类型 Type* 数组类型 Type[] 枚举类型 enum

复合数据类型联合类型 union 结构类型 struct 类类型 class 图2.1 C++的数据类型

图中Type表示

非控数据类型。

2.1.1 基本数据类型

逻辑型：又称布尔型，用关键字bool表示。有两个值true或false。true可以转换成整数1，false可以转换成整数0。与此对应，整数也可以隐式的转换成bool值：非0的整数转换成true,0转换成false。

字符型:用关键字char表示。取值包含具体实现所用的字符集里的一个字符。字符型数据通常占用1个字节的存储空间。

整型：用关键字int表示。取值是计算机所能表示的所有整数。

浮点型:包括单精度型(float)和双精度型(double)。单精度型通常占用4个字节的存储空间，双精度型通常占用8个字节的空间。

空类型：用关键字void表示。用于说明某个函数没有返回值。没有void类型的对象。

在基本的数据类型前可以添加修饰符，以改变基本类型的意义。 signed：有符号。 unsigned：无符号。

unsigned和signed只用于修饰char和int，且signed修饰词可以省略。当用unsigned修饰词时，后面的类型说明符可以省略。对于有符号和无符号的整型数据，它们所占的存储空间的大小相同，但它们的表数范围却不相同（对字符型意义相同）。

short：短型。只用于修饰int，且用short修饰时，int可以省略。

long：长型。只用于修饰int和double。当用long修饰int时，int可以省略。

数据类型的描述确定了其内存所占空间的大小，也确定了其表示范围。用sizeof(数据类型)可以确定某数据类型的字节长度。请读者查看在你所用的机器上，下面类型的最大值和最小值是什么：char、short、int、long、float、double、long double 、unsigned。

409--24

2.1.2 复合数据类型

数组：由具有相同数据类型的元素组成的集合。

结构体：由不同的数据类型构成的一种混合的数据结构，构成结构体的成员的数据类型一般不同，并且在内存中分别占据不同的存储单元。

共用体：是类似于结构体的一种构造类型，与结构体不同的是构成共同体的数据成员共用同一段内存单元。

枚举：将变量的值一一列举出来，每个枚举成员（枚举符）都与一个整数相对应。按默认方式，枚举符所赋的值从0开始递增。枚举的值也可以用整型的表达式赋值进行初始化。如果某个枚举中所有枚

举符的值均非负，该枚举的表示范围是[0: 2 -1]，其中2是能使所有枚举符位于此范围内的最小的

2的幂；如果存在负的枚举符值，该枚举的取值范围就是[-2：2 -1]。

指针类型:指针类型变量用于存储另一变量的地址，而不能用来存放基本类型的数据。它在内存中占据一个存储单元。

类类型:类是体现面向对象程序设计的最基本特征，也是体现C++与C最大的不同之处。类是一个数据类型，它定义的是一种对象类型，由数据和方法组成，描述了属于该类型的所有对象的性质。

2.2变量与常量

2.1.1 变量：指在运行期间其值可以改变的量。变量有三个特征：变量类型、变量名、变量值。命名：遵循标识符命名规则。

标识符是对实体定义的一种定义符，用来标识用户定义的常量名、变量名、函数名、文件名、数组名、和数据类型名和程序名等。只能由字母、数字和下划线组成，且以字母或下划线开头。命名时注意以下几点：

1． C++的关键字不能用作用户自定义的实体名；

2．以下划线开头的名字是保留给实现或者运行环境，用于特殊目的，在应用程序里不要采用这样的

名字；

3．大写与小写字母是区分的； 4．见名知义。

5．维持统一的命名风格。定义：

格式： <类型名><变量名>[[=<表达式>],?]

typedef：为某种类型声明一个新名字，而不是定义一种新类型。格式：typedef <已有类型名> <新类型名>

2.1.2 常量：程序执行期间其值不变的量。主要有下列几类常量。布尔常量字符常量

用单引号括起的一个字符。在内存中，字符数据以ASCII码存储，如字符‘a’的ASCII码为97。以转义字符‘\\’开始的字符常量后跟不同的字符表示不同的特殊字符。字符串常量

由一对双引号括起来的零个或多个字符序列。

字符串可以写在多行上，不过在这种情况下必须用反斜线‘\\’表示下一行字符是这一行字符的延续。字符串常量实际上是一个字符数组，组成数组的字符除显示给出的外，还包括字符结尾处标识字符串结束的符号‘\\0’，所以字符串“abc”实际上包含4个字符：‘a’、‘b’、‘c’和‘\\0’。

注意字符常量与字符串常量在表示、存储、运算方面的区别。整型常量

可以用十进制、八进制或十六进制表示。

十进制常量：一般占一个机器字长，是一个带正负号的常数（默认情况下为正数）。八进制常量：由数字0开头，其后由若干0-7的数字组成，如0378，0123等。

十六进制常量：以0x或0X开头，其后由若干0-9的数字及A-F（或小写a-f）的字母组成，如0x123，0x3ab。

浮点型常量

只能以十进制形式表示。共有两种表示形式：小数表示法和指数表示法。如：11.3、.2、2.3e10、-2.3E-1等。

409--25

枚举常量

枚举声明形式: enum <枚举名>{<枚举符表>}；枚举符可以有两种形式：

<枚举符名>/<枚举符名>=<整形常量> 符号常量

定义形式：const <类型名> <符号常量名>=<表达式>[,?]； []表示可选项，以下都采用这种标记。

定义的符号常量必须初始化。一个符号常量可看作是一个只读变量，由const定义的常量的值不可以改变。const的最常见的用途是作为数组的界和作为分情况标号。

2.3 运算符与表达式

在程序中，表达式是计算求值的基本单位，它是由运算符和运算数组成的式子。运算符是表示进行某种运算的符号。运算数包含常量、变量和函数等。C++语言的运算符按其在表达式中与运算对象的关系（连接运算对象的个数）可分为：单目运算、双目运算、三目运算。 C++运算符一览表名称作用域区分符分量运算符函数调用运算符下标运算符后增量、后减量前增量、前减量求字节运算符正号、负号指针运算符 :: . -> （） [] ++ -- ++ -- sizeof + - * 和 & 运算符 ::x p.next,p->next fac() p[10] p++ --p sizeof(int) -1,+3 *p,&x p=new int; delete p; (int)x 3%5(取模) 8>>3, 8<<3 3<5 3!=5 4 5 6 7 8 9 10 11 12 13 3 14 15 16 左结合性右结合性左结合性 2 3 3 右结合性举例优先级 1 2 结合性左结合性分配、回收空间运算符 New delete 强制类型转换运算符算术运算符左移、右移关系运算符位运算符（type） * / % + - << >> <<= > >= == != &(按位“与”) 1&2 ^(按位“异或”) 1^2 |(按位“或”) 1|2 && || ! ? : x&&y x||y !x a>b?x:y 逻辑运算符条件运算符赋值运算符逗号运算符 = 及其扩展（+= a=2 -= *= /= %= 等） a+=2 , a=1,b=2,c=3 表2.1 C++运算符一览表

2.4 简单输入与输出在C++中，I/O使用了流的概念-字符（或字节）流。每一个I/O 设备传送和接收一系列的字节，称之为流。输入操作可以看成是字节从一个设备流入内存，而输出操作可以看成是字节从内存流出到一个设备。

409--26

要使用C++标准的I/O流库的功能，需要包括两个头文件：iostream.h用于提供基本的输入输出功能，iomanip.h用于提供格式化的功能。

2.4.1 I/O的书写格式（基本数据类型的输入输出）头文件iostream.h包含有cin和cout对象，对应于标准输入流和标准输出流。流读取运算符“>>”表示流的输入，可以从cin输入流中读取字符；流插入运算符“<<”表示流的输出，可以向cout输出流插入字符。

如：cout<<”hello world.”<

cin>>i>>j; //输入i，j的值

2.4.2使用控制符（基本数据类型输入输出的格式控制）

C++中提供了大量的用于执行格式化输入输出的格式控制符，具体名称及作用请参看表2.2。

控制符描述所在头文

件

置基数为10 dec iostream.h 置基数为16 hex

置基数为8 oct

设填充字符为c setfill(c)

设显示小数精度为n位 setprecision(n)

设域宽为n个字符 setw(n)

固定的浮点显示 setiosflags(ios::fixed) iomanip.h setiosflags(ios::scientific) setiosflags(ios::left) setiosflags(ios::right) setiosflags(ios::skipws)

指数表示左对齐右对齐忽略前导空白

setiosflags(ios::uppercase) 16进制数大写输出 setiosflags(ios::lowercase) 16进制数小写输出

setiosflags(ios::showpoin) 显示小数点 setiosflags(ios::showpos)

显示符号（正负号）

setiosflags(ios::showbase) 指定在数值前输出进制（0表示八进制，0x或

0X表示十六进制）

表2.2 I/O流的常用控制符

【典型例题】

例题1：对以下各种数据类型比较所占用存储空间的大小：

(1）char、int、short int、long int、double、long double. (2) signed int、unsigned int. 解答：

(1) 本题主要考查的知识点是各种类型所占用的存储空间的大小以及相应的表数范围。在32位计算机中，char占1个字节，short int 占2个字节，int占4个字节，long int占4个字节，double占8个字节。sizeof运算符用于求解某种数据类型的大小。short和long在修饰整型时可以省略int。答案为：

(2)对于一种确定的数据类型有符号数与无符号数所占的存储空间相同，表数范围不同。修饰符signed和unsigned只能用于修饰字符型和整型。答案为：

例题2：下列哪一项能用作用户自定义的标识符：

(a)const (b)2var (c)my name (d)var2 解答：

409--27

本题主要考查标识符命名规则。C++关键字不能用于用户自定义标识符，(a)中const是关键字；第一个字符必须是字母或下划线，(b)中2var是以数字开头；不能含有空格，(c)中my name含有空格。答案为：d。

例题3：指出下列程序中的错误：__________。 int main() {

const int x; x=100; return 0; } 解答：

本题主要考查对符号常量的理解。const定义的符号常量必须初始化,由const定义的常量的值不可以改变。所以本题有两处错误：第一、没有对符号常量x进行初始化；第二、给符号常量赋值是错误的。

例题4：给下列表达式加上全部的括号(假设所用变量均已定义): (1) a+b-c--%b

(2) a>b?b:c>d?a:c

本题主要考查表达式中运算符的优先级与结合性。请参阅表2.1。为了避免出错，建议读者在书写表达式时完整书写括号。

(1)答案为：(a+b)-((c--)%b)

(2)答案为：a>b?b:(c>d?a:(c

例题5：请根据下列题意写出相应的表达式。

(1) 有a、b、c、max四个变量a、b、c中的最大值，并将结果放入max中。 (2) 年龄在1到100之间（包含1和100，年龄用变量age表示）。

(3) 公式。

(4) 判断一年是否为闰年，年用year表示。满足下列两个条件之一即为闰年：①能被4整除但不

能被100整除 ②能被400整除。

解答：

（1）主要考查对条件表达式的理解和书写。答案为：max=a>b?(a>c?a:c):(b>c?b:c)。（2）主要考查对逻辑表达式的理解和书写。答案为：1<=age&&age<=100。（3）主要考查如何在计算机中表示一个数学公式。答案为：(a+b)*h/2。

（4）主要考查对逻辑表达式的理解和书写。答案为：(year%4==0&&year0!=0)||(year@0==0)。

例题6:下列选项中两个表达式的运算结果相同的是（）。

(a)3/2和3.0/2.0 (b)3/2和3.0/2 (c) 3/2.0和3.0/2.0 (d) 3/2.0和3/2 解答：

本题考查数据类型及表达式中数据类型的隐式转换。3/2中两个操作数都为整型，运算结果仍为整型即1；3.0/2和3/2.0中一个操作数为整型另一个为浮点型，运算时整型隐式转换为浮点型，运算结果也为浮点型即1.5；3.0/2.0两个操作数均为浮点型，结果也为浮点型即1.5。答案为：(c)。

例题7:

下列程序的运行结果为：______________。

409--28

#include void main() {

int a=2,b=4,i=0,x; x=a>b&&++i;

cout<<\：\ cout<<\：\}

解答：

本题主要考查“短路”表达式的运算。对于表达式中的“与”运算而言，只要有一个操作数为假，结果为假。所以当第一个操作数为假时，不在求解其它操作数。对于表达式中的“或”运算而言，只要有一个操作数为真，则结果为真。所以当第一个操作数为真时，不在求解其它操作数。本题中a>b为假，所以表达式a>b&&++i为假，而++i没有执行。故i为0。答案为:x:0 i:0

例题8:求解下列各表达式的值（其中x的值为100）。

(1) (a=1,b=2,c=3) (2) 1|3<<5

(3) 'a'+3&&!0%1

(4) x%2？“odd”:” even” 解答：

(1) 逗号表达式的值是其最后一个表达式的值。答案为：3。

(2) <<运算符的优先级高于|运算符，所以先算3<<5结果为96（二进制1100000），然后与1做按位与运算

则结果为97（二进制1100001）。答案为：97。

(3) 参与本题的运算符，按优先级由高到低依次是：!运算符、算术运算符、逻辑运算符。'a'+3时字符型

首先隐式转换成整型然后相加结果为100，!0%1即1%1结果为0，100&&0结果为0。答案为：0。 (4) 算术表达式的优先级高于条件表达式，所以先算x%2结果为0，0?”odd”:”even”结果为”even”。

本题完成判断一个数是奇数还是偶数，若该数为奇数，则表达式的值为”odd”，为偶数，则表达式的值为”even”。答案为：”odd”。

例题9:下列程序运行结果为：_______________。 #include #include void main() {

int a=23;

double b=23.123456789; cout<

cout<

解答：

本题主要考查对格式化输入输出的掌握。 ①本题主函数中第三行输出a,b，’\\t’为转义字符，其含义是跳过一个制表位。不设置输出宽度时，默认输出6位有效数字，超出部分四舍五入。所以该行输出为：23 23.1235。

② setprecision(n)设置显示精度，最少显示一位有效数字。如果不重新设置，则其保持效力，所以使用

409--29

完后要还原为6位默认值。第四行中设置setprecision(0)与setprecision(1)作用相同，结果显示一位有效数字即为：2e+001。

③ setiosflags(ios::fixed)为固定的浮点显示，其后跟setprecision(n)表示小数点后显示精度为n。所以第五行输出结果为：23.1234568。

④ setiosflags(ios::scientific)为指数显示，当其整数部分宽度大于设置的显示精度（默认为6位）时，以指数形式显示结果。否则根据设置的（或默认的）显示精度显示n位有效数字。所以第六行输出结果为：23.12346。

⑤ setiosflags(ios::showbase)为指定在数值前输出进制。hex置基数为16，且该操作保持效力，所以使用完后应该恢复为默认值10进制。第九行输出结果为：0x17 0x17。

⑥setw(n) 设域宽为n个字符，setfill(c) 设填充字符为c ，setiosflags(ios::left)为左对齐。第十一行输出结果为：23********。答案为：

23 23.1235 2e+001 23.1234568 23.12346 0x17 0x17 23********

【习题】一、选择题

1. 下列数据类型不是C++语言基本数据类型的是（）。

(a）字符型 (b）整型 (c）浮点型 (d）数组

一、下列字符列中，可作为C++语言程序自定义标识符是（）。选择题

(a)x (b）-var (c)new (d)3i 3. 下列数中哪一个是8进制数（）。

(a)0x1g (b)010 (c)080 (d)01b

4. 已知a=1,b=2,c=3，则表达是++a||-b&&++c的值为（）。

(a)0 (b)1 (c)2 (d)3 5. 下列表达式选项中，（）是正确的。

(a)++(a++) (b)a++b (c)a+++b (d)a++++b 6. 已知枚举类型定义语句为：（）。

enum color{RED,BLUE,PINK=6,YELLOW,GREEN,PURPLE=15}; 则下列叙述中错误的是（）。

(a)枚举常量RED的值为1 (b)枚举常量BLUE的值为1 (c)枚举常量YELLOW的值为7 (d)枚举常量PURPLE的值为15 7. 下列程序的运行结果正确的是（）。

#include #include void main() {

const double pi=3.1415926;

cout<

(a) 3.142

3.142

**3.14159260 (b) 3.14

3.142

409--30

**3.14159260 (c) 3.14

3.14

3.14159260** (d) 3.14

3.142

***3.1415926

8. 若int x=3,y=5;则表达式x&y++%3的值为（）。

(a)0 (b)1 (c)2 (d)3 9. 下列常量正确的是（）。

(a) ”hello (b)1FL (c) 3.14UL (d) 1.8E-3 World”

10. 若char x=97;,则变量x包含几个字符（）。

(a)1个 (b)2个 (c)4个 (d)8个

二、填空题

1. c++语言标示符是以字母或__________开头的，由字母、数字、下划线组成。 2. 在C++语言中，char型数据在内存中的存储形式是__________。

3. 在内存中，存储字符‘x’占用1个字节，存储字符串“x”要占用________个字节。 4. 符号常量可以用宏定义define和__________表示。 5. 转义字符序列中的首字符是_________。 6. 空字符串的长度是__________。

7. 表达式cout<<’\\n’;还可以表示为__________。

8. 若要为unsigned int定义一个新的名字UINT应采用的语句是__________。 9. 以下程序不借助第3个变量实现a,b值得交换，请填空。

#include Void main() {

int a,b;

cout<<”输入a,b：”; cin>>a>>b;

a=___a+b_______; b=_____a-b_____; a=______(a-b)/2;

cout<

10. 大多数C++程序都要包含头文件__________。该文件中包含了所有输入/输出流操作所需的基本信

息。当使用带参数的操作时，程序中必须包含头文件__________。

三、编程题

1. 编写一个程序，输入一个三位数，分别输出该数的百位、十位和个位。

2. 编写一个程序打印出各种基本数据类型、几个你自己定义的复合数据类型的大小。使用sizeof运

算符。

【参考答案】

一、选择题

1． d 2． a 3． b 4． b 5． c 6． a

409--31

7． b 8． c 9． d 10． a 二、填空题

1．下划线 2． ASCII 3． 2 4． const 5． \\ 6． 0

7． cout<

8． typedef unsigned int UINT; 9． a+b a-b a-b

10． iomanip.h iostream.h 三、编程题 1．

#include void main() {

int num,var1,var2,var3;

cout<<\请输入一个三位数：\ cin>>num;

if(num>999||num<100) //用于检查输入数据的合法性 cout<<\您的输入有误!\ else { var1=num/100; var2=(num-var1*100)/10; var3=num; cout<<\百位数为：\ <<\十位数为：\ <<\个位数为：\ } }

2．

#include #include void main() {

int array[10]; enum month{Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec}; char *p; cout<<\ <<\ <<\ <<\ <<\ <<\ <<\ <<\ <<\ <<\ <<\ <<\ }

409--32

第3章 C++程序的流程控制

【内容提要】顺序控制语句选择控制语句循环控制语句跳转语句

【重点与难点】 3.1 顺序控制语句

指按照语句在程序中出现的先后次序一条一条的顺次执行。包含声明语句，表达式语句，输入输出语句等。

3.1.1 表达式语句

任何一个表达式（上一章中给出了详细介绍）后面加上一个分号就构成了表达式语句（没有分号的不是语句）。常见的表达式语句有以下几种：空语句、赋值语句、函数调用语句等。空语句：指只有一个分号而没有表达式的语句，它不作任何操作和运算。格式为：；

空语句被用在程序的语法上要求一条语句而逻辑上却不需要的时候。

函数调用语句：是由函数调用表达式加一个语句结束标志（分号“；”）构成的语句。函数的定义和使用请参见第五章中的详细介绍。 3.1.2 输入/输出语句

C++程序没有输入/输出语句，它的输入/输出功能由函数（scanf、printf）或流控制来实现。printf和scanf是标准的输入输出函数，主要在C程序设计中使用，其声明包含在头文件stdio.h中。在C++中，I/O流完全取代了它们，使用I/O流输入输出时，必须包含头文件iostream.h。从键盘输入语句格式为： cin>>表达式1[>>表达式2>>?]；向屏幕输出语句格式为： cout<<表达式1[<<表达式2<

注意：连续输入多项数据时应键入空白字符（包括空格键、回车键和Tab键）将相邻的两项数据分开。而连续输出时，cout不会在相邻数据项间加分隔符，为了增强显示效果，用户可通过控制符自定义显示宽度，换行等（部分控制符在iomanip.h头文件中声明）。 3.1.3 复合语句

C++语言允许把一组语句用一对花括号括起来，构成一个复合语句。复合语句被视为一个独立的单元它可以出现在程序中任何单个语句可以出现的地方复合语句不需要用分号作为结束。注意空语句；和空复合语句 { } 是等价的。

3.2 选择控制语句

针对于不同情况采用不同的处理方式的问题，用选择结构来实现。选择语句包含：if语句和switch语句。

3.2.1 if语句

if语句：

格式：if(<条件表达式>) <语句>

作用：当<条件表达式>为真时，执行<语句>，否则直接执行if语句后边的语句。

409--33

这里的<语句>可以是一条语句，也可以是几条语句，但对于多条语句的情况必须用{ }将几条语句括起来构成复合语句，在if语句中当做一个整体处理。

if?else语句：

格式：if(<条件表达式>)

<语句1> else

<语句2>

作用：当<条件表达式>为真时，执行<语句1>；当<条件表达式>为假时，执行<语句2>。这里<语句1>和<语句2>可以是一条语句也可以是复合语句。说明：

①if语句有时可以用条件表达式替代。

②if语句支持多种形式的嵌套使用，但一般嵌套层次不超过三层。另外约定else总是与它上边最近的一个if配对。为了防止语法或逻辑错误的发生，建议在较复杂的情形中使用花括号区分。 3.2.2 switch语句

格式：switch(<表达式>){

case <常量表达式1>：<语句序列1> case <常量表达式2>：<语句序列2> ?

case <常量表达式n>：<语句序列n> [default：<语句序列n+1>] }

作用：计算<表达式>判断它与哪个<常量表达式>匹配，执行第一个相匹配的<常量表达式>后的语句，直到遇到break转去执行switch语句以外的语句；如果均不匹配则执行default后定义的语句（在default省略的情形中，直接执行switch语句以外的语句）。说明：

①switch语句中的<表达式>的值只能是整型、字符型或枚举型表达式。

②switch语句中，case和其后的<常量表达式>间必须有空格否则会产生逻辑错误。case后的<常量表达式>的值是互不相同的，且它的类型与switch后的<表达式>的类型一致。

③通常情况下，每个case分支语句结束后都要加一个break语句来结束switch语句。但在要表示一个范围，或描述一类对象时（如A,B,C都属于合格，D属于不合格）有可能几条case分支语句后才有一个break语句。

④switch语句与嵌套的if语句都可以用于处理多分支选择的问题。

3.3 循环控制语句

对于同一个语句或同一组语句序列需要重复多次，则采用循环结构。C++提供了三种循环控制语句：while语句，do?while语句，for语句。 3.3.1 while语句

格式：while(<条件表达式>) <语句>

作用：判断<条件表达式>是否为真，若为真则执行<语句>，然后重复判断，直到<条件表达式>为假时跳出while循环执行其后的语句。

说明：

①这里的<语句>可以是单条语句也可以是复合语句。

②当<条件表达式>在循环开始就不满足，则不执行while循环也就是说while循环有可能一次都不执行。

3.3.2 do?while语句格式： do{

<语句>

}while(<条件表达式>)；

作用：当流程到达do后，立即执行循环体语句，然后再对条件表达式进行判断。若<条件表达式>的值为真，则重复执行循环体语句，直到<条件表达式>为假时退出循环，执行do?while循环后的语句。说明：这种循环中<语句>至少执行一次，当条件在循环开始时就不满足时这种做法是危险的，所以应尽量使用while语句而避免使用do?while语句。

409--34

3.3.3 for语句

格式：for(<表达式1>；<表达式2>；<表达式3>) <语句>

作用：<表达式1>可以称为初始化表达式，一般用于对循环变量进行初始化或赋初值；<表达式2>可以称为条件表达式，当它的判断条件为真时，就执行循环体<语句>，否则终止循环，退出for循环；<表达式3>可以称为修正表达式，一般用于在每次循环体执行之后，对循环变量进行修改操作。

说明：

①这里的<语句>可以是一条语句也可以是复合语句。

②for循环中三个表达式可能省略一个、两个或三个都省略，但它们之间分号在三种情况下都不可以省略。

3.4 跳转语句 3.4.1 break语句

格式：break；

作用：结束当前正在执行的循环（for、while、do?while）或多路分支（switch）程序结构，转而执行这些结构后面的语句。

说明：在循环结构中使用时，如果有多层循环，只跳出其所在的最近的循环层。 3.4.2 continue语句

格式：continue；

作用：结束当前正在执行的这一次循环（for、while、do?while），接着执行下一次循环。即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环语句的判定。

【典型例题】

例题1：下列程序的运行结果为__________。 #include void main( ) {

char c=’@’ ;

if (c>='A' && c<='Z') cout<<\是大写字母 \ else if (c>='a' && c<='z') cout<<\是小写字母\ else cout<<\是其它字符\ } 解答：

本题主要考查if语句的嵌套使用方法。首先判断字符变量c是否满足c>='A' && c<='Z'，如果满足则输出\是大写字母 \；否则判断c是否满足c>='a' && c<='z'，如果满足则输出\是小写字母\否则输出\是其它字符\。else总是与离它最近的前一个if配对。答案为：是其它字符。

例题2：已定义：char grade; ，若成绩为A、B、C时输出合格，成绩为D时输出不合格，其他情况提示重新输入。要完成以上功能，则下列switch语句正确的是（）。 (a) switch(grade){

case ‘A’: case ‘B’:

case ‘C’: cout<<”合格”;break; case ‘D’: cout<<”不合格”;break; default: cout<<”请重新输入：”; }

(b) switch(grade){

case ‘A’: case ‘B’:

case ‘C’: cout<<”合格”; case ‘D’: cout<<”不合格”; default: cout<<”请重新输入：”; }

(c) switch(grade){

409--35

case‘A’, ‘B’, ‘C’: cout<<”合格”;break; case ‘D’: cout<<”不合格”;break; default: cout<<”请重新输入：”; }

(d) switch(grade){

case A: case B:

case C: cout<<”合格”;break; case D: cout<<”不合格”;break; default: cout<<”请重新输入：”; } 解答：

本题主要考查switch语句的使用。在switch语句执行过程中，找到第一个相匹配的表达式后，转去执行该case后的语句，直到遇到break语句后跳出switch语句执行其后的语句。对于选项b，若grade的值为A则执行结果为“合格不合格请重新输入”，不满足本题的要求；switch语句多个case分支不能简写为多个表达式之间用逗号隔开的一个case分支，选项c错误；case后的表达式只能是整型、字符型或枚举型常量表达式，选项d中case后的A、B、C、D是变量。答案为：a。

例题3：找出并改正下列程序段中的错误：

(1) if(x>0);-------------①

y=x+1;-------------② else;----------------③ y=x-1;-------------④

(2) While(i) --------------------①

{ cout<

while(i<=100) ------② { sum+=i; -----------③ i++;}-------------④ (4) int i=1,sum=0;-------------①

do{ -----------------------② sum+=i; -----------------③ i++;}while(i<=100) ------④

解答：

本题中包含了初学者在编程中容易犯的一些错误，提醒读者注意。

(1)本题考查对if语句的语法结构的掌握。本题的错误在于在if和else后不应加分号。答案为：将①、③句末的分号去掉。

(2)C++是大小写敏感的语言。答案为：将①中While改为while。

(3)本题目的是完成1到100求和，结果放在sum中，但是sum在参与运算前应该首先对其赋值。答案为：将①改为 int i=1,sum=0;

(4)本题主要考查对do?while的语法结构的掌握以及与while结构进行对比区别两者在作用和语法上的不同。答案为：将第④行while后加分号即while(i<=100);

例题4：循环语句for(int i=0;i<=5&&!i;i++) cout<

本题考查对for循环的理解以及表达式运算。执行for循环i的初值为0，第一次循环时表达式0<=5&&!0结果为1所以执行循环体输出0；然后i自加为1，计算表达式1<=5&&!1结果为0，所以退出循环。答案为：a。

例题5：程序段：

int i,sum=0;

409--36

for(i=1;i<=100;sum+=i,i++);

与上边程序段不等价的是（）。 (a) int sum=0,i=1;

do{

sum+=i++;

}while(i<=100);

(b) int i=1,sum=0;

while(i<=100)

{ sum+=i++; }

(c) int i=1,sum=0;

while(1) {

if(i>100) break; sum+=i++; }

(d) int i,sum=0;

for(i=1;i<=100;i++,sum+=i); 解答：

本题主要考查对各种循环结构的以及它们之间转换关系的理解。本题中的程序段是求解1到100的和，循环结束后i的值为101，sum的值为5050。选项a、b分别用do?while和while循环完成求解1到100的和；选项c是永真循环，通过break语句退出循环，其作用也是求解1到100的和；选项d中i先自加然后求和，其作用为求解2到101的和，循环结束后i的值为101，sum的值为5150。答案为：d。

例题6：运行下列程序的结果为（1）____________________。（2）___________________。（1）

#include void main() {

int x,y,cmultiple;

cout<<\输入两个整数:\ cin>>x>>y; cmultiple=x; while(1) {

if(cmultiple%y==0)break; cmultiple+=x; }

cout<<\最小公倍数:\}

输入：24 7 （2）

#include void main() {

int x,y,var1;

cout<<\输入两个整数：\ cin>>x>>y;

if(x

409--37

{

x=y;y=var1;var1=x%y; }

cout<<\最大公约数:\}

输入：24

7 解答：

本题考查理解程序的能力。(1)中求解两个数x,y的最小公倍数思路为若x能够被y整除则x就是这两个数的最小公倍数，否则判断x的整数倍是否能被y整除，直到x的某个倍数可以被y整除，则该数即为这两个数的最小公倍数。(2)中求解两个数x,y的最大公约数思路为用两个数中较大的数作为被除数，较小的数作为除数，如果能够整除则较小的数就是这两个数的最大公约数，否则，将较小的数作为新的被除数，将两个数的模作为除数，重复以上工作直到模为0，则这个除数就是x和y的最大公约数。答案为：(1) 最小公倍数:168 (2) 最大公约数:1

例题7：以下程序的功能是输出1到100之间每位数的乘积大于每位数的和的数，如对数字12有1*2<1+2，所以不输出这个数；对数字23有2*3>2+3所以输出这个数。请填空。 #include void main() {

int num,product=1,sum=0,n; for(num=1;num<=100;num++) {

product=1;sum=0;

________①__n=num ______; while(_____②__n___) {

product*=n;sum+=n; _______③__n/=10____; }

if (product>sum) cout<

解答：

本题中变量num用于表示1到100的整数，变量product用于存放每位数的乘积，变量sum用于存放每位数的和，变量n用于存放求解每位数的中间结果。外层for循环用于控制判断1到100的数，内层while循环用于计算每位数的积与每位数的和，if语句用于判断该数的每位数的乘积是否大于每位数的和，若满足此条件，则输出这个数。在①处要对n赋值，最初它是num的副本而后用于存放计算每位数的中间结果；②处为退出while循环的条件，当当前这个数的每位数都被取出，则内层循环结束；③改变循环变量的语句，使得循环在某种情况下可以结束，这里取n除10的商，直到商为0时结束内层循环。答案为：① ② ③

例题8：以下程序的功能是判断一个数是否为素数。请填空。 #include void main() {

int num;

cout<<\输入一个正整数：\ _________①________; int isprime=1;

for(int i=2;i<=num-1;i++) if(________②________)

409--38

{

isprime=0;

______③______; } if(isprime)

cout<

解答：

本题中变量num存放要判断的数，变量isprime用于记录该数是否为素数，当isprime为1时即该数为素数，否则为合数。判断思路为如果num能被2到num-1的任意一个数整除则该数不是素数。①处需要输入待判断的数，②处为判断条件，当检测到2到num-1中第一个能整除num的数时则可判断出该数不是素数，此时退出循环，故③为退出语句。

答案为： ①cin>>num ②num%i==0 ③break

例题9：编写一个程序，输入一个正整数，判断它是否能被3，5，7同时整除。解答：

参考程序如下

#include void main() {

int num;

cout<<\请输入一个正整数：\ cin>>num; if(num<0)

cout<<\输入有误!\ else

if(num%3==0&&num%5==0&&num%7==0)

cout<

例题10：编写一个程序，让用户输入年和月，然后判断该月有多少天。解答：

算法思想：判断某年某月有多少天，每个月的天数有四种可能：1、3、5、7、8、10、12月为31天，4、6、9、11月为30天，闰年的2月有29天，不是闰年则2月为28天。因为每月的天数有多种可能，我们选择用switch语句解决本题。程序流程是首先输入要判断的年月，然后判断该年月应有多少天，最后输出结果。

参考程序如下： #include void main() {

int year,month,days,leap; cout<<\请输入年月:\ cin>>year>>month; switch(month) {

case 1: case 3: case 5:

409--39

case 7: case 8: case 10:

case 12:days=31;break; case 4: case 6: case 9:

case 11:days=30;break; case 2:if(year@0==0) leap=1;

else if(year%4==0&&year0!=0) leap=1; else leap=0; if(leap) days=29; else days=28; }

cout<

例题11：编写一个程序。计算若一头母牛，它每年年初生一头小母牛，每头小母牛从出生起第四个年头开始每年也生一头小母牛，按此规律，第10年时有多少头母牛？解答：算法思想：

假设f(n)表示第n年的母牛数，已知f(0)=0,f(1)=2,f(2)=3,f(3)=4,推得在第n年时应有f(n-3)头母牛生育出f(n-3)头母牛，所以第n年共有f(n-1)+f(n-3)头母牛。据此得出数学表达式：f(n)=f(n-1)+f(n-3)。在下边的参考程序中分别用变量sum、sum1、sum2、sum3表示f(n),f(n-1),f(n-2),f(n-3)其中n从4变化到10。

参考程序如下：

#include void main() {

int sum1=2,sum2=3,sum3=4,sum=0,n=10; for(int i=4;i<=n;i++) {

sum=sum1+sum3; sum1=sum2; sum2=sum3; sum3=sum; }

cout<<\第十年有\头牛!\ }

例题12：计算

当通项

时停止计算。

409--40

解答：算法思想：

本题主要考查学生对循环结构的运用以及对数学问题编程技巧的掌握。本题为有规律的若干项相加，所以采用循环结构处理。循环的条件是当

时继续运算直到这个条件不满足时就达到了题目要求的精

度，则停止运算。循环体中完成三件事，首先是求出本次（第i次）循环中的的值，然后计算当前的e，最后完成循环变量增1的操作。在求解本题时主要注意计算中所采用的变量的数据类型以及如何完成运算精度的控制。参考程序如下：

#include int main() {

double e=1.0; double x=1.0; int i=1;

while(x>=1.0e-7) {

x=x/i; e=e+x; i=i+1; }

cout << \ return 0; }

【习题】

一、选择题

1．在循环语句中使用break语句的作用是（）。

(a)结束本次循环 (b)结束该层循环 (c)结束所有循环 (d)结束程序执行 2．对if后的括号中的表达式，要求i不为0的时候表达式为真，该表达式表示正确的为（）。

(a)i (b)!i (c)i<>0 (d)i=0 3．下列循环语句的执行次数是（）。

while(!1) cout<<”ok!”;

(a)0次 (b)1次 (c)2次 (d) 无数次 4．运行下列程序结果为（）。

#include void main() {

int i;

for (i=0;i<=10;i++){

if (i%2) cout<

(a)246810 (b)12345 (c)678910 (d)13579

二、填空题

1．结构化程序设计的三种基本结构是__________、__________、__________。 2． continue语句实现的作用是________________________________________。

3．若输入”china 2008!”,运行下列程序的输出结果为___________________________。 #include #include

409--41

void main( ) {

char c;

int letters=0,digits=0,others=0;

cout<<\ while ((c=getchar( ))!='\\n') {

if (c>='a' && c<='z' || c>='A' && c<='Z' ) letters++; else

if (c>='0' && c<='9') digits++; else

others++; }

cout<<\ <<\ <<\ }

4．本程序完成1!+2！+??+18!的计算，请将程序补充完整。 #include #include void main() {

double sum=0,fac=1; for(int i=1;i<=18;i++) {

___________①____________

____________②___________ }

cout<<\??+18!=\

三、编程题

1. 输入某学生成绩，若成绩在90-100输出＂优秀＂，若成绩在80-89输出＂良好＂，若成绩在70-79

输出＂中＂，若成绩在60-69输出”及格”，若成绩在0-59输出”不及格”。 2. 输入三人数，按从小到大的大顺序输出。

3. 在100～200中找出同时满足用3除余2，用5除余3和用7除余2的所有整数。

4. 求100～999中的。所谓水仙花数是指一个三位数，它的每位数字的立方之和等于该数。例如，因为

333

153＝1＋5＋3，所以153为水仙花数。

5. 求1000之内的所有完数。所谓完数是指一个数恰好等于它的所有因子之和。例如，6＝1＋2＋3，所

以6为完数。

6. 编一程序显示如下图案：

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

409--42

* * * *

7. 编一程序显示如下图案：

A A B C A B C D E A B C D E F G

8. 猴子吃桃问题。猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。第二天早上

又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，发现只剩一个桃子了，求猴子第一天究竟摘了多少个桃子？

9. 编程序模拟剪刀，石头和纸游戏。游戏规则为：剪刀剪纸，石头砸剪刀，纸包石头．玩游戏者从键盘

上输入Ｓ（表示剪刀）或Ｒ（表示石头）或Ｐ（表示纸），要求两个游戏者交替输入，计算机给出输赢的信息。

10. 编写程序输出菲波那切数列的前20项。即前两项为1，以后每一项为前两项之和。 11. 打印九九乘法表。

【参考答案】一、选择题 1. b 2. a 3. a 4. d

二、填空题

1．顺序结构、选择结构（分支结构）、循环结构 2．跳出本次循环。 3．

please input a line charaters letters:5 digits:4 others:2

4．①fac*=i; ②sum+=fac;

三、编程题 1．

#include void main() {

double grade; char* degree;

cout<<\请输入学生成绩：\ cin>>grade;

if(grade>100||grade<0) {

cout<<\您的输入有误!\ return; } else

if(grade>=70) if(grade<80) degree=\中\ else if(grade<90)

409--43

degree=\良好\ else

degree=\优秀\ else if(grade>=60) degree=\及格\ else

degree=\不及格\

cout<<\分数:\ <

#include void main() {

int num1,num2,num3,num; cout<<\请输入三个整数：\ cin>>num1>>num2>>num3; if(num1>num2) {

num=num1; num1=num2; num2=num; }

if(num1>num3) {

num=num1; num1=num3; num3=num; }

if(num2>num3) {

num=num2; num2=num3; num3=num; }

cout<<\三个数按从小到大输出为：\ <

#include void main() {

cout<<\在100～200中同时满足用3除余2，用5除余3和用7除余2的整数为：\ for(int i=100;i<=200;i++) {

if(i%3==2&&i%5==3&&i%7==2) cout<

#include #include

409--44

void main() {

int x,y,z,sum;

cout<<\～999中的水仙花数为：\ for(int i=100;i<=999;i++) {

x=i/100; y=i0/10; z=i;

sum=pow(x,3)+pow(y,3)+pow(z,3); if(i==sum)

cout<

#include void main() {

int sum;

cout<<\之内的所有完数为：\ for(int i=1;i<=1000;i++) {

sum=0;

for(int j=1;j<=i/2;j++) if(i%j==0) sum+=j; if(i==sum)

cout<

#include void main() {

int i,j,n;

cout<<\请输入上三角行数：\ cin>>n;

for(i=1;i<=n;i++) {

for(j=1;j<=(n-i)*2;j++) cout<<' ';

for(j=1;j<=2*i-1;j++) cout<<\ cout<

for(i=n-1;i>=1;i--) {

for(j=1;j<=(n-i)*2;j++) cout<<' ';

for(j=1;j<=2*i-1;j++) cout<<\ cout<

409--45

#include #include void main() {

int i,j; char x;

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

x='A';

for(j=1;j<=2*(4-i);j++) cout<<' ';

for(j=1;j<=2*i-1;j++) {

cout<

#include void main() {

int peach=1;

for(int day=1;day<10;day++) //day表示n天前 peach=2*(peach+1);

cout<<\猴子第一天摘了\个桃子！\} 9．

#include void main() {

char play1,play2; char* result;

cout<<\请两位玩家顺序输入Ｓ（表示剪刀）或Ｒ（表示石头）或Ｐ（表示纸）：\ cin>>play1>>play2;

if((play1=='R'||play1=='S'||play1=='P')&&(play2=='R'||play2=='S'||play2=='P')) {

switch(play1) {

case 'S':

if(play2=='R') result=\玩家2赢！\ else if(play2=='P') result=\玩家1赢！\ else result=\平局！\ break; case 'R':

if(play2=='P') result=\玩家2赢！\ else if(play2=='S') result=\玩家1赢！\ else result=\平局！\ break; case 'P':

if(play2=='S') result=\玩家2赢！\ else if(play2=='R') result=\玩家1赢！\ else result=\平局！\ break;

409--46

}

cout<

cout<<\输入有误!\} 10．

#include void main() {

int item,item1=1,item2=1;

cout<<\菲波那切数列的前20项为：\ cout<

item=item1+item2; cout<

#include #include void main() {

cout<

for(int title=1;title<=9;title++) cout<

for(int row=1;row<=9;row++) {

cout<

for(int line=1;line<=row;line++) cout<

第4章数组

【内容提要】一维数组二维数组多维数组

【重点与难点】 4.1 数组的基本概念

数组是由一组具有相同数据类型的元素组成的集合。数组的类型就是这组元素的数据类型。构成数组的这组元素在内存中占用一组连续的存储单元。可以用一个统一的数组名标识这一组数据，而用下标来指明数组中各元素的序号。根据数组维数的不同，可分为一维数组、二维数组和多维数组，常用的是一维和二维数组。 4.1 一维数组

4.1.1一维数组的定义与初始化

409--47

一维数组的定义

定义格式：类型数组名[常量表达式]；说明：

①类型为第二章中介绍的数据类型，这里的类型是数组的类型也就是数组中每个元素的类型。 ②数组名是一个标识符，代表数组在内存中的起始地址。数组中各元素在内存中连续存储。

③常量表达式又称下标表达式，就是数组中的元素个数。通常采用符号常量，这样使得程序的伸缩性更强。

一维数组的初始化

在定义数组时对其中的全部或部分元素指定初始值，这称为数组的初始化。初始化的格式为：类型数组名[常量表达式]={值1，值2，?，值n}；说明： ①只有存储类别为静态的或外部的数组才可以进行初始化。 ②当初始化的元素比数组中的元素个数少时，则按顺序对前一部分元素赋初值，其余元素自动初始化为0或空字符‘\\0’（对字符数组）；当初始化的元素超过数组元素个数时，编译器会报错。 ③当初始化元素个数与数组实际元素个数相等时，可以省略数组长度但[]不能省略。

④对字符数组进行初始化可以对每个数组元素一一赋初值，也可将一个字符串直接赋值给一个数组。但要注意数组长度除了包含字符串中字符个数还包含一个’\\0’字符。

4.1.2 访问数组元素

格式：数组名[下标]

说明：对于一个有n个元素的数组，其下标从0开始到n-1。在引用时要防止越界引用，这样会引起逻辑错误。可以通过sizeof(数组名)/sizeof(数组类型)来求得实际的数组长度。

4.2 二维数组

4.2.1 二维数组的定义与初始化二维数组的定义

定义格式：类型数组名[常量表达式1][常量表达式2]；说明：

①数组名是一个标示符，代表数组在内存中的起始地址，二维数组按“先行后列”的顺序被存储在一维的存储空间中的。

②常量表达式1表示数组的行数，常量表达式2表示数组的列数。二维数组的初始化

对二维数组的初始化主要有两种形式：

第一、数值按行用花括号分组对二维数组初始化。第二、所有数值按顺序在一个花括号中给出。说明：

①对以上两种形式，如果没有给出所有数组元素，则剩余元素自动初始化为0。

②若在一个花括号中对所有元素赋初值或者按行用花括号分组而组内元素部分或全部赋值，则可以缺省第一维的长度，但是[]不能省略，并且在任何情况下，二维数组第二维的长度均不可省略。

4.2.2 访问数组元素

格式：数组名[下标1][下标2] 说明：

若该数组为n行m列的二维数组，则下标1从0到n-1，下标2从0到m-1。【典型例题】

例题1：下面定义数组的语句正确的是（）。 (a) int i=6;char a[i]= “hello”;

(b) const int i=5;char a[i]= “hello”; (c) char a[6]=”hello”; (d) char a5=”hello”; 解答：

本题主要考查字符数组在定义及初始化时需要注意的问题。数组定义中数组长度不能指定为除const变量以外的变量，选项a中i为变量；选项b中字符串“hello”含有6个字符，而数组a的长度是5所以编

409--48

译器报错；选项d中a5是一个字符变量而不是字符数组，而“hello”含有6个字符，无法放在一个字符变量中。所以答案为：c

例题2：已知数组a定义为：int a[][3]={{1,2,3},{4}};，则a[1][2]的值为（）。 (a)2 (b)3 (c)4 (d)0 解答：

在对数组进行初始化时只给出部分元素的初始值，则剩余元素自动初始化为0。答案为：d。

例题3：已知数组定义为int a[2][4];，下列对数组元素引用正确的为（）。 (a)a[1,2] (b)a[1][2] (c)a(1,2) (d)a[1][4] 解答：

对二维数组的引用格式为：数组名[下标1][下标2]；n行m列的二维数组其第一维的下标从0到n-1，第二维的下标从0到m-1。选项a和c引用格式错误，d中下标越界。答案为：b。

例题4：下列程序段错误的是（）。 (a) char str1[8];

cin>>str1; (b) char str1[8];

strcpy(str1,”first”); (c) char str1[8];

for(int i=0;i<7;i++) cin>>str1[i]; str1[7]=’\\0’;

(d) char str1[8],str2[8]=”first”;

str1=str2; 解答：

本题主要考查如何为字符数组赋值。为字符数组赋值可以直接从键盘输入一个字符串、用strcpy函数将一个字符串复制到该字符数组或者用循环语句逐个为字符数组元素赋值。不能直接将一个数组赋值给另一个数组。答案为：d。

例题5：下列说法正确的是（）。

(a)数组可以存放不同类型的元素。 (b)定义int a[2];,则数组a有两个数组元素。 (c)定义int a[3];,则该数组中元素分别为：a[0],a[1],a[2],a[3]。 (d)在编译时，不必确定数组的大小。解答：

数组中所有的元素具有相同类型，选项a错误；定义int a[3];则数组a中含有三个元素分别为a[0],a[1],a[2]，选项c错误；编译时必须确定数组的大小，即在定义数组时必须给出数组长度。答案为：b。

例题6：运行下列程序结果为________________。 #include #include void main() {

int array1[3][3]={{1,2,13},{4,5,16},{7,8,9}},i=0,j=2,sum1=0,sum2=0; for(;i<3;i++) {

sum1+=array1[i][i]; sum2+=array1[i][j--]; }

cout<

409--49

解答：

本题中程序的作用是对一个给定的3×3矩阵求出其主对角线元素值之和与逆对角线元素值之和然后输出计算结果。其中主对角线上的元素即为行和列下标相同的元素，逆对角线元素下标满足行下标从小到大依次递增同时列下标从大到小依次递减的元素。答案为：15 25。

例题7：下列程序的作用是检查字符串s中是否包含字符串t，若包含，则返回并输出t在s中的开始位置（下标值），否则返回-1。请将程序补充完整。 #include int main() {

int i,j,k;

char s[20]=\ for(i=0;s[i]!='\\0';i++) {

for(j=i,k=0;_______①_________ &&s[j] == t[k];j++,k++); if(________②________) {

cout<<\在s中的开始位置下标为:\ return i; } }

return -1; }

解答：

本程序用于解决检查一个字符串是否包含于另一个字符串。程序的思想是从s串的第0个字符起与t串进行比较，若到t串结束时所比字符均相等则说明t在s中，返回t在s中的开始位置，程序结束；否则从s的第1个字符起重复以上操作，依此类推直到匹配或s串结束为止。程序中变量i用于记录本轮中正在与t串相比较的s串的子串的首字符位置（下标），k用于记录t串中当前比较字符的位置（下标），j用于记录s串中当前比较的字符的位置（下标）。因此，答案为：①t[k]!='\\0' ②t[k]=='\\0'

例题8：编程实现任意输入10个数，然后按从小到大的顺序输出这10个数。解答：

算法思想：关于排序问题的实现算法非常多。有插入排序、希尔排序、快速排序、选择排序、归并排序、基数排序等。在时间空间复杂度方面这些算法各有优缺点。有关这方面的内容可以参考数据结构方面的介绍。在这里给出了一个采用简单选择排序的参考程序。其思路为循环n-1次（n为元素个数），每次循环都从剩下的数中选择出最小的一个。如下给出排序过程：下标i 0 1 2 3 list[i] 100 34 20 200 第1轮 34 100 20 200 20 100 34 200 第2轮 20 34 100 200 第3轮 20 34 100 200

参考程序：

#include #include int main() {

const int COUNT=10; int list[COUNT]; int i,j,tmp;

cout<<\请输入10个数：\

409--50

Word文档下载：C++编程练习题大全（带答案）.doc

搜索更多:C++编程练习题大全（带答案）

最新浏览

2011年9月全国计算机等级考试二级笔试
安康市城乡居民社会养老保险实施办法(试行
鏂版敼鍦熷湴缈昏€曟柦宸ョ粍缁囪?璁?- 鐧惧
最新新审定人教版五年级数学下册第三单元长方体和
2019-2020学年广东省广州市白云区九年级
2019年中国钛行业分析与未来发展趋势报告(定
六年级数学稍复杂的分数应用题专项练习
部编版七年级历史下册第8课《金与南宋的对峙》练
(优辅资源)湖南省娄底市高二下学期期末考试数学
上海合景广场桩基工程施工组织设计[1]

热门浏览

全国自学考试建筑经济与企业管理试题 - 图文
烟草诗词及文化
2018年高考化学总复习非选择题系列练题33
华南理工大学2007~2008学年度学生教育工作表彰光荣册 - 图文
C++编程练习题大全（带答案）
华南理工大学2007~2008学年度学生教育工作表彰光荣册 - 图文
烟草诗词及文化
中医儿科学题库 doc
第二篇机械创意机构设计基础
(9套试卷合集)2020江西省抚州市高考第六次大联考理综物理试卷