C++程序设计 第二讲 清华大学软件学院

考试情况 名单人数：355 (179) 交卷数：350 白卷数：197(55%) 免修的同学： 14班 03D586 张 研 清华大学软件学院

第3,9,10题答题(白卷除外)情况 第3题 第 9题 第10题 不及格 128 120 146 及格 22 17 4 满分 13 13 清华大学软件学院

第二章 基本数据类型 清华大学软件学院

字符集与关键字 C++字符集的组成： C++关键字(保留字)：预先定义好的，对C++编译程序有特殊的含义的符号； 26个字母(大写A~Z、小写a~z) 10个数字(0~9) 其他符号：+-*/=,._:;?”\’(空格) ~|!#%&()[]{}^<> C++关键字(保留字)：预先定义好的，对C++编译程序有特殊的含义的符号； 标识符(identifier)： 清华大学软件学院

命名规则 C++区分大小写。 合法的标识符： “好”的标识符： 不能是C++关键字，不要与C++中的库函数名、类名和对象名相同。 由字母、数字和下划线组成，不能以数字开头，中间不能有空格。 “好”的标识符： 在语意清晰、不含歧义的前提下，尽可能简短。 保持统一的风格。 清华大学软件学院

一些指导方针： 使用大小写进行区分：numTeamMembers 在命名变量时，用名词：distance 在命名函数时，用动词：PrintPayroll, StringLength 在命名常量时，用大写：MAX_VALUE 长度适中。 清华大学软件学院

匈牙利命名法 (Hungarian Notation) Charles Simonyi 提出的一种变量命名方法，使用各种前缀来表明变量的数据类型。 数据类型 前缀 例子 int i iIndex, iCount char c cInChar, cSerialOut 指针类型 p pMsg, pServer char * sz szName FILE * pf pfInFile, pfOutFile 清华大学软件学院

C++数据类型 整型 int 单字符型 char 字符型 宽字符型 wchar_t 基本数据类型 单精度型 float 实型 非基本数据类型 整型 int 字符型 实型 逻辑型 bool 单字符型 char 宽字符型 wchar_t 单精度型 float 双精度型 double 数组 type [ ] 指针 type * 空类型 void 结构 struct 联合 union 枚举 enum 类 class 清华大学软件学院

数据类型 基本数据类型和非基本数据类型； 数据类型修饰符： long, short, signed, unsigned 数据类型的描述确定了其内存所占空间大小，也确定了其表示范围； 在不同的计算机上，每种变量类型占用的内存空间的长度不一定相同； 清华大学软件学院

常量和变量 数据以变量或常量的形式来描述； 常量(constant)：在程序运行过程中，值不能被改变的量。 变量(variable)：在程序运行过程中，值可以被改变的量。 清华大学软件学院

常量定义(1) 定义：关键字const 常量定义时必须初始化 常量定义中初始化的值可以是一个常量表达式，但不能包含函数。 const float pi=3.1415926; //OK const float pi; pi=3.1415926; //Error 常量定义中初始化的值可以是一个常量表达式，但不能包含函数。 const int size=100*sizeof(int); //OK const int size=max(15,25); //Error 清华大学软件学院

常量定义(2) 编译预定义指令(#define) #define PI 3.1415926 清华大学软件学院

通过 b 可以找到相应的存储单元地址XXXX 变量 b 变量名 ————变量值 存储单元地址XXXX 30 变量定义的语法：数据类型 变量列表; 变量列表：变量1, 变量2, …, 变量N int lower, upper, step; char c, line[1000]; 通过 b 可以找到相应的存储单元地址XXXX 清华大学软件学院

整型数据 数据类型 说明 字节数 比特数 取值范围 int 整型 4 32 -231  (231 – 1) short int 短整形 2 16 -215  (215 – 1) long int 长整型 unsigned int 无符号整型 0  (232 – 1) unsigned short 无符号短整形 0  (216 – 1) unsigned long 无符号长整型 [signed] 在32位系统上各种整型数据的长度 清华大学软件学院

短整型的表示范围： -32768 -32767 … -2 -1 0 1 2 … 32766 32767 负数区 非负区 1 …… -32768 -32767 … -2 -1 0 1 2 … 32766 32767 负数区 非负区 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 …… ＝－32768 ＝－32767 ＝ 0 ＝ 32766 ＝ 32767 符号位 清华大学软件学院

无符号短整型的取值范围： 1 …… ＝ 0 ＝ 32767 ＝ 65534 ＝ 65535 ＝ 1 清华大学软件学院 2 3 4 5 6 7 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 …… ＝ 0 ＝ 32767 ＝ 65534 ＝ 65535 ＝ 1 清华大学软件学院

整型常量 123L, 123l, 56U, 56u 表示方式： 十进制，如123，- 456，0； 八进制，以0开头的数。 0123＝00123＝000123≠123 0123＝(123)8＝1×82＋2×81＋3＝83 十六进制，以0x开头的数。 0x123＝(123)16＝1×162＋2×161＋3＝291 123L, 123l, 56U, 56u 清华大学软件学院

实型数据 实数类型(浮点类型) 存放形式：小数部分＋指数部分 单精度浮点类型(float) 双精度浮点类型(double) 长双精度浮点类型(long double)。 存放形式：小数部分＋指数部分 + .314159 1 实数3.14159： 实数符号 小数部分 指数部分 101 × ＝3.14159 清华大学软件学院

小数部分占的位数越多，数据的有效数字越多，精度越高；指数部分占的位数越多，则能表示的数值范围越大。 类型 比特数 有效数字 数值范围 float 32 6~7 10-38 ~ 1038 double 64 15~16 10-308 ~ 10308 清华大学软件学院

实型常量 表示形式： 十进制小数形式，如： .123, 123., 123.0, 0.0； 指数形式，如321.54E6＝321.54e6＝321.54×106； 12.5, 12.5f, 12.5L, 12.5e34f, 12.5E34L 清华大学软件学院

字符型数据 一个字符型数据只占用一个字节的存储空间。 字符常量：用单引号括起来的一个字符，如’a’, ’x’, ’A’, ’#’。 特殊形式的字符常量：以”\”开头的字符序列。 清华大学软件学院

转义字符表 ‘\101’ =‘A’ =‘\x41’ 符号 ASCII值 含义 \a 007 响铃 \b 008 退格 \n 010 换行 \r 013 回车 \t 009 水平Tab键 \v 011 竖直Tab键 \’ 039 单引号 ’ \” 034 双引号 ” \\ 092 反斜杆 \ \ooo － 八进制表示的字符 \xhhh 十六进制表示的字符 ‘\101’ =‘A’ =‘\x41’ 清华大学软件学院

字符变量 将一个字符常量赋值给字符变量，实际上是将该字符相应的ASCII码存到内存单元中。 char ch=’a’; 等价于 char ch=97; C++中字符数据和整型数据之间可以通用，可以相互赋值，只要注意其表示的范围合理。 int a=’b’; //OK;给一个整型变量赋字符值 char c=97; //OK;给一个字符变量赋整型值 清华大学软件学院

字符串常量 字符串常量：用一对双引号括起来的一串字符序列，如：”How do you do.”, ”China”, ”a”, ”$123.45 ”。 存储方式：字符串中的每一个字符占用一个内存单元，最后增加一个空操作字符‘\0’结尾。 H o w d y u . \0    C h i n a \0 a \0 ’a’ ＝ ≠ a $ 1 2 3 . 4 5 \0 清华大学软件学院

字符串常量与字符常量的区别 ’a’与”a”的不同 ’a’的存储形式为： ”a”的存储形式为： a a \0 清华大学软件学院

枚举(enumeration) 定义： enum 类型名 {枚举常量值序列}; 枚举类型将枚举的取值一一列举出来； enum weekday {sun,mon,tue,wed,thu,fri,sat}; 枚举类型将枚举的取值一一列举出来； 枚举常量在内存中用整型数表示，如果没有专门指定，第一个枚举常量值为0，其它依次向上加1。 enum COLOR {RED=100, BLUE, GREEN=200}; 清华大学软件学院

变量的声明与定义 定义(define)：为这个名字分配相应的存储空间（只能一次）。 声明(declare)：向计算机介绍一个名字的含义（可以多次）； int student; //变量的定义 & 声明 extern int student; //变量声明而没有定义 外部变量 清华大学软件学院

变量的赋值与初始化 可以用赋值运算符”=”给变量赋值，也可以在定义变量的同时使变量初始化。 int i=0; int i; i=0; 清华大学软件学院

int i = 0; //定义一个整型变量，初始值为0 int a = 3, b, c = 3; //只初始化 a 和 c float eps = 1.0e-5; //定义并初始化一个实型变量 char esc = ’\\’; //定义一个字符变量，初始值为’\’ enum COLOR{RED＝100,BLUE,GREEN＝200}; COLOR paint=GREEN; //定义枚举类型的变量 COLOR paint2=200; //Error 清华大学软件学院

第三章 表达式 清华大学软件学院

表达式(expression) 表达式是由一个或多个操作数(operand)和操作符(operator)构成；其目的是用来说明一个计算过程。 操作符：应用在操作数上的操作； 如：a*b/c-2.5+ ’A’ 表达式可以嵌套：2+(5*sizeof(int))/6 表达式根据某些类型转换约定、求值次序、结合律和优先级规则来进行计算。 清华大学软件学院

操作符 1. 算术运算符 ＋ － * / % 2. 关系运算符 > < == >= <= != 3. 逻辑运算符 ＋ － * / % 2. 关系运算符 > < == >= <= != 3. 逻辑运算符 ! && || 4. 位运算符 << >> ~ | ^ & 5. 赋值运算符 = 及其扩展赋值运算符 6. 条件运算符 ? : 7. 逗号运算符 , 8. 指针运算符 * & 9. 求字节运算符 sizeof 10. 强制类型转换运算符 (类型) 11. 分量运算符 . -> 12. 下标运算符 [ ] ...... 清华大学软件学院

算术运算符 (Arithmetic Operators) 算术运算符：＋，－，*，/，% 算术类型转换：如果运算符带有不同数据类型的运算对象，那么需要根据一些转换规则，把它们先转换成一种共同的数据类型，然后再进行运算。 转换总是朝着表达数据能力更强的方向，并且转换总是逐个运算符进行的。 清华大学软件学院

char short int long int unsigned char unsigned short unsigned int unsigned long float double long double 清华大学软件学院

算术类型转换 例如： int i; float f; double d; long e; 表达式：10+’a’+i*f-d/e 清华大学软件学院

强制类型转换运算符 形式：类型名 (表达式) 强制类型转换只是得到一个所需类型的中间变量，原来变量的类型并不发生变化； float (a) (float)(a) (float)a (int)(x+y) //将(x+y)强制转换为int 型 int (x+y) //将(x+y)强制转换为int 型 (int)x+y //将x转换为int型后再与y相加 强制类型转换只是得到一个所需类型的中间变量，原来变量的类型并不发生变化； 清华大学软件学院

增量、减量运算符 Increment and Decrement Operators ++、--：使变量的值加 1 或减 1； ++i、--i：在使用 i 之前，先使 i 的值加 1 或减 1； i++、i--：在使用 i 之后，使 i 的值加 1 或减 1； 例如 i = 3 j = ++i; // i 的值先变成4，再赋值给 j，因此 j＝4 j = i++; // 先把 i 的值3赋给 j，然后 i 变成4 清华大学软件学院

关系与逻辑运算 关系运算符(Relational Operators)：==，>，<，>=，<=，!= 逻辑运算符(Logical Operators) ： ！，&&，|| 清华大学软件学院

赋值运算符 (Assignment Operators) 赋值运算符 ”=” ：它的作用是把一个数据或表达式的值赋给一个变量。 复合的赋值运算符：在赋值运算符”=”之前加上其他运算符，可以构成复合的赋值运算符，如+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|= 变量 Op= 表达式 等价于 变量 = 变量 Op 表达式 清华大学软件学院

a += 3 等价于 a = a + 3 x *= y + 8 等价于 x = x * (y + 8) x %= 3 等价于 x = x % 3 清华大学软件学院

赋值类型转换 如果赋值运算符两侧的类型不一致，但都是数值型或字符型时，在赋值时要进行类型转换； 将实型数据（包括单、双精度）赋值给整型变量； 将整型数据赋值给单、双精度浮点变量； 将double型数据赋值给float变量； 将float型数据赋值给double变量； 清华大学软件学院

将int、short、long 型数据赋值给一个 char 型变量； 将带符号的short型数据赋值给int或long型变量； 将字符型数据赋值给整型变量； 将int、short、long 型数据赋值给一个 char 型变量； 将带符号的short型数据赋值给int或long型变量； 将unsigned short型数据赋值给int或long型变量； 将非 unsigned型数据赋值给长度相同的unsigned型变量； 清华大学软件学院

求字节数运算符 求字节数运算符：sizeof 返回一个对象或者类型名的字节长度； 对于数组，返回整个数组的字节长度； 例如：求int型数据所占的字节数： sizeOfInt=sizeof(int)=4; short int a[5]; sizeOfArray=sizeof(a)=10; 清华大学软件学院

逗号表达式 一般形式是： 表达式1,表达式2,……,表达式n 求解顺序为从左至右； 如：int a,b,c; a=1, b=a+2, c=b+3; 整个逗号表达式的值是表达式n的值。 如：a=(3+2,6*4,7-4); //a的值为3 清华大学软件学院

位运算符(Bitwise Operators) 实例 说明 10进制值 二进制值 x 操作数 011 0 0 0 0 1 0 0 1 y 027 0 0 0 1 0 1 1 1 ~x 位取反 366 1 1 1 1 0 1 1 0 x & y 按位与 001 0 0 0 0 0 0 0 1 x | y 按位或 037 0 0 0 1 1 1 1 1 x ^ y 按位异或 036 0 0 0 1 1 1 1 0 x << 2 位左移 044 0 0 1 0 0 1 0 0 x >> 2 位右移 002 0 0 0 0 0 0 1 0 清华大学软件学院

优先级与结合性 表达式求解时，先按运算符优先级的高低次序执行； 如果在一个运算对象两侧的运算符的优先级别相等，则按规定的“结合方向”处理； a=3*5, a*4; () 如果在一个运算对象两侧的运算符的优先级别相等，则按规定的“结合方向”处理； 左结合性：3 * 5 / 4 等价于 (3*5)/4 右结合性： i = j *= 2 等价于 i = (j *= 2) nA * 4 + nB * 3 + nC * 2 3 1 12 2 15 17 清华大学软件学院

清华大学软件学院 优先级 操作符 结合性 1 () [] -> :: . 左 2 ! ~ + - ++ -- & * () sizeof new delete 右 3 .* ->* 4 * / % 5 + - 6 << >> 7 < <= >= > 8 == != 9 & 10 ^ 11 | 12 && 13 || 14 ?: 15 = *= /= += -= |= <<= >>= %= &= ^= &&= ||= 16 , 清华大学软件学院

求值次序与副作用 对于复合表达式来说，不同的编译器求值的顺序会不同； 例如：int a=3, b=5, c; c=a*b+ ++b; c=a*b+ ++b; c=a*b+ ++b; 15 6 21 VC: 6 24 18 BC: 清华大学软件学院

c=a*b + ++b; c=++b + a*b; 求值顺序使括号失去作用； int a=3, b=5, c; 求值顺序使交换律无效； c=a*b + ++b; c=++b + a*b; 求值顺序使括号失去作用； int a=3, b=5, c; c= ++b * (a+b); 解决表达式副作用的方法：分解表达式语句； c = a+b; ++b; c *= b; 清华大学软件学院

输入输出 标准输入输出函数：printf和scanf； I/O流 #include <stdio.h> #include<iostream.h> 清华大学软件学院

printf函数 格式： printf(格式控制字符串,输出项1,输出项2, …) 格式控制字符串由普通字符和格式说明组成，普通字符照原样输出，格式说明由“％”和格式字符组成，其作用是指定输出数据的格式。 输出项是需要输出的一些数据，可以是表达式。 清华大学软件学院

常用格式符 %格式符 输出说明 %d 10进制整数 % o 8进制整数 % x 16进制整数 % u 无符号10进制整数 % c 字符 % s 字符串 % f 浮点数的小数形式 % e 浮点数的指数形式 % g 浮点数(自动选择f或e格式) 清华大学软件学院

printf(“%3d,%c,%d,%f,%12.7f,%-12.7f”, a, b, b, c, c, c); int a=28; char b=’D’; double c=3.1415926; printf(“%3d,%c,%d,%f,%12.7f,%-12.7f”, a, b, b, c, c, c); 28,D,68,3.141593, 3.1415926,3.1415926 清华大学软件学院

scanf函数 格式： scanf(格式控制字符串,地址1,地址2, …) 地址n是变量的地址，而不是变量名； 如果在格式控制字符串中，有除格式说明外的其他字符，则在输入数据时要在对应的位置上输入相同的字符。 清华大学软件学院

scanf(”%d%d,%d",&a,&b,&c); printf("%d,%d,%d",a,b,c); 输入：10 2,5 int a,b,c; scanf(”%d%d,%d",&a,&b,&c); printf("%d,%d,%d",a,b,c); 输入：10 2,5 输出：10,2,5 清华大学软件学院

I/O流 #include <iostream.h> 标准输入的istream对象cin 标准输出的ostream对象cout 操作符： << 输出操作符 >> 输入操作符 cin, cout自动识别变量位置和类型； 清华大学软件学院

#include <iostream.h> void main( ) { char name[20]; int age; cout<<”please give your name:” <<endl; cin>>name; cout<<”please give you age:” <<endl; cin>>age; cout<<”your name is :”<<name <<endl; cout<<”you are”<<age <<”years old”<< endl; } 清华大学软件学院

I/O流常用控制符(manipulator) #include <iomanip.h> 控制符 描述 dec 十进制 hex 十六进制 oct 八进制 setfill(c) 设填充字符为c setprecision(n) 设显示小数精度为n setw(n) 设域宽为n 清华大学软件学院

运行结果： #include <iostream.h> #include <iomanip.h> void main() { float amount=3.14159; cout<<setw(12)<<amount<<endl; cout<<setfill('*')<<setw(10)<<amount<<endl; cout<<setprecision(2)<<amount<<endl; } 运行结果： _ _ _ _ _ 3.14159 ***3.14159 3.1 清华大学软件学院

int number=1000; cout<<"decimal:"<<dec<<number<<endl; cout<<"hexadecimal:"<<hex<<number<<endl; cout<<"octal:"<<oct<<number<<endl; cout<<hex; cout<<123<<endl; cout<<234<<endl; cout<<345<<endl; cout<<dec; 运行结果: decimal:1000 hexadecimal:3e8 octal:1750 7b ea 159 清华大学软件学院

第四章 过程化语句 清华大学软件学院

语句(statement) 简单语句(Simple Statement)和复合语句(Compound Statement)； 语句按功能分类： 操作运算语句：用于描述计算机执行的操作运算，如表达式语句； 过程化语句：控制操作运算的执行顺序，如循环控制语句； 清华大学软件学院

结构化程序设计的3种基本控制结构 分支结构 顺序结构 循环结构 基本控制结构 清华大学软件学院

//输入三角形的三条边长，求三角形的面积 #include <iostream.h> #include <math.h> void main() { double a,b,c,s,area; cin >> a >> b >> c; s = (a + b + c) / 2.0; area = sqrt(s*(s-a)*(s-b)*(s-c)); cout << "a=" << a << ", b=" << b << ", c=" << c << ", Area of the triangle is: " << area <<endl; } 清华大学软件学院

分支结构(选择结构) 条件成立，执行A，条件不成立，执行B； 分情况讨论，不同的情况执行不同的语句； 情况n 情况1 An A1 …… 真 假 清华大学软件学院

关系运算符 关系运算(比较运算)：把两个值进行比较； 6 种关系运算符： (1) < （小于） (2) <=（小于或等于） (3) > （大于） (4) >=（大于或等于） (5) ==（等于） (6) != （不等于） 优先级相同（高） 优先级相同（低） 清华大学软件学院

例如：a > b == c 等价于 (a > b) == c a == b < c 等价于 a == (b < c) 优先级高 算术运算符: +、－、*、/、% 关系运算符: >、<、==、>=、<=、!= 优先级低 赋值运算符: ＝ 例如：c > a + b 等价于 c > (a + b) a = b > c 等价于 a = (b > c) 清华大学软件学院

关系表达式 关系表达式：用关系运算符将两个表达式连接起来的式子。 关系表达式的值是一个逻辑值，即“真”(true)或“假”(false)。 a > b a + b > b + c (a = 3) > (b = 5) ‘a’ < ‘b’ (a > b) > (b < c) 关系表达式的值是一个逻辑值，即“真”(true)或“假”(false)。 清华大学软件学院

逻辑运算符 3 种逻辑运算符 a b !a !b a&&b a||b true false &&（逻辑与，双目运算符）：a&&b 清华大学软件学院

关系运算符: >、<、==、>=、<=、!= a>b && x>y 等价于(a>b) && (x>y) !a || a>b 等价于 (!a) || (a>b) 优先级高 算术运算符: +、－、*、/、% 关系运算符: >、<、==、>=、<=、!= 赋值运算符: ＝ 优先级低 ！（逻辑非） &&（逻辑与）和 ||（逻辑或） 清华大学软件学院

逻辑表达式 系统在给出逻辑运算结果时，以1代表真，以0代表假；而在参加逻辑运算的运算对象中，以0代表假，以非0（不一定是1）代表真。 y = 4 && 5; // y = 1 y = (!4) || 0; // y = 0 y = ‘c’ && ‘d’; // y = 1 清华大学软件学院

#include <iostream.h> main( ) { int a=0,b=1,c=1,d; d=a&&(b=b+1)||(c=c+1); cout<<"a="<<a<<endl; cout<<"b="<<b<<endl; cout<<"c="<<c<<endl; cout<<"d="<<d<<endl; } 预计： a=0 b=2 c=2 d=1 运行结果为： a=0 b=1 c=2 d=1 清华大学软件学院

逻辑表达式 在逻辑运算中，并不是所有的逻辑运算符都被执行，只有在必须执行下一个运算符后才能得出表达式的值时，才执行该运算符。 例如： a && b && c a || b || c 清华大学软件学院

if语句 根据所给条件是否满足来决定执行哪种操作； if语句： if(表达式) 语句体1; 如果表达式为真，执行语句体1；否则什么都不做； if (num!= 0) average = sum / num; 清华大学软件学院

if-else语句：if(表达式) 语句体1； else 语句体2 如果表达式为真，执行语句体1；否则执行语句体2； 清华大学软件学院

cout << ” Better luck next time!” << endl; } if (playScore > computerScore) { cout << ”You win! ” << endl; } else { cout << ” You lose! ” << endl; cout << ” Better luck next time!” << endl; } 清华大学软件学院

条件运算符 条件运算符(The Condition Operator)语法： 求解过程： 例如： if(a > b) max = a; (条件表达式)?(条件为真时的表达式):(条件为假时的表达式) 求解过程： 例如： if(a > b) max = a; else max = b; 等价于 max=(a>b)? a:b a=1,b=2,c=3,d=4 a>b?a:c>d?c:d 4 清华大学软件学院

if (表达式1) 语句1； else if (表达式2) 语句体2； else if (表达式3) 语句体3； …… else if (表达式m) 语句体m； else 语句体m+1； 清华大学软件学院

编一程序，实现下列函数 x y -1 1 清华大学软件学院

if-else语句配对规则：else连接到上一个没有配对的且可见的if上。 y=0; if (x >= 0) if(x>0) y = 1; else y = -1; y=0; if (x >= 0) { if(x>0) y = 1; } else y = -1; y=0; if (x >= 0) { if(x>0) y = 1; else y = -1; } if-else语句配对规则：else连接到上一个没有配对的且可见的if上。 清华大学软件学院

#include <iostream.h> void main( ) { int x, y; cin >> x; if (x > 0) y = 1; else if (x == 0) y = 0; else y = -1; cout << ”x=” << x << ”, y=” << y << endl; } 清华大学软件学院

switch语句 switch(表达式) 当switch表达式和某个case常量表达式的值相同时，就从该case表达式开始向后执行； { …… case 常量表达式n：语句体n; default : 语句n+1; } 当switch表达式和某个case常量表达式的值相同时，就从该case表达式开始向后执行； 清华大学软件学院

switch (rank) { case 1: cout<<“冠军”<<endl; points = 10; break; case 2: cout<<“亚军”<<endl; points = 5; break; case 3: cout<<“季军”<<endl; points = 2; break; default: cout<<“鼓励奖”<<endl; points = 1; } if (rank == 1) { cout<<“冠军”<<endl; points = 10; } else if (rank == 2) { cout<<“亚军”<<endl; points = 5; } else if (rank == 3) { cout<<“季军”<<endl; points = 2; } else { cout<<“鼓励奖”<<endl; points = 1; } 清华大学软件学院

switch (day) { case 0: cout<<“星期天”; break; case 1: switch (day) { case 0: cout<<“星期天”; break; case 1: cout<<“星期一”; break; case 2: cout<<“星期二”; break; case 3: cout<<“星期三”; break; case 4: cout<<“星期四”; break; case 5: cout<<“星期五”; break; case 6: cout<<“星期六”; break; default: cout<<“无效的数字”; break; } switch (day) { case 0: case 6: cout<<“周末”; break; case 1: cout<<“星期一”; break; case 2: cout<<“星期二”; break; case 3: cout<<“星期三”; break; case 4: cout<<“星期四”; break; case 5: cout<<“星期五”; break; default: cout<<“无效的数字”; break; } 清华大学软件学院

循环结构 当条件成立时，反复执行A，当条件不成立时，跳出循环； A 条件 真 假 清华大学软件学院

问题描述：如图所示，显示前100个整数的平方和立方； 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 ... ... ... 清华大学软件学院

for语句 for(表达式1;表达式2;表达式3) 循环体 循环体 表达式2 真 假 表达式1 表达式3 清华大学软件学院

#include <iostream.h> #include <iomanip.h> main( ) // 显示前100个整数的平方和立方 #include <iostream.h> #include <iomanip.h> main( ) { int i; for ( i = 1; i <= 100; i++) { cout << setw(5) << i << setw(7) << i*i << setw(10) << i*i*i << endl; } 清华大学软件学院

执行结果： 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000 11 121 1331 ...... ...... ...... 清华大学软件学院

对于 for 语句的一般形式中的“表达式1” 可以是设置循环变量初值的赋值表达式； for (i = 0; i <= 100; i++) sum = sum + i; 可以被省略，此时应在 for 语句之前给循环变量赋初值。当省略表达式1时，其后的分号不能省略； for (; i<=100; i++) sum = sum + i; 可以是与循环变量无关的其他表达式；可以是一个简单的表达式，也可以是逗号表达式； for (sum = 0; i <= 100; i++) sum = sum + i; for (sum = 0, i = 1; i <= 100; i++) sum = sum + i; 清华大学软件学院

for (i = 0; (c = getchar()) != ‘\n’; i += c); 可以被省略，即不判断循环条件，循环无终止地进行下去。也就是认为表达式2的值始终为真。此时程序设计者应另外设法保证循环能正常结束； for ( i = 1; ; i++) sum = sum + i; 一般是关系表达式或逻辑表达式，但也可以是数值表达式或字符表达式，只要其值为非零，就执行循环体。 for (i = 0; (c = getchar()) != ‘\n’; i += c); 清华大学软件学院

对于for语句的一般形式中的“表达式3” 可以被省略，即没有循环变量增值，此时程序设计者也应能保证循环能正常结束； for (i = 1; i <= 100;) { sum = sum + i; i++;} 可以是一个简单的表达式，也可以是逗号表达式。 for (i = 0, j = 100; i <= j; i++, j--) k = i + j; 一般是作为循环变量增值，但也可以是对循环变量进行减值，而且每一步不一定非要加 1 或减 1，也可以是其他的常量。 清华大学软件学院

问题描述：依次显示从1开始的其立方值小于10000所有整数及其平方和立方值。 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 … … … 21 441 9261 清华大学软件学院

while语句 循环体 改变循环变量 条件 表达式 真 假 循环变量初始化 while(条件表达式) 循环体 清华大学软件学院

//显示从1开始的前若干个整数的平方和立方 //只要其立方值小于10000。 #include <iostream.h> #include <iomanip.h> main( ) { int i=1; while ( i * i * i < 10000) { cout << setw(5) << i << setw(7) << i*i << setw(10) << i*i*i << endl; i++; } 清华大学软件学院

#include <iostream.h> #include <iomanip.h> main( ) { int i; for ( i=1; i * i * i < 10000; i++) { cout << setw(5) << i << setw(7) << i*i << setw(10) << i*i*i << endl; } 清华大学软件学院

do...while语句 do 循环体 while(条件表达式) 先执行一次语句， 再判断表达式是否成立。 循环变量初始化 循环体 改变循环变量 条件 表达式 真 假 循环变量初始化 do 循环体 while(条件表达式) 先执行一次语句， 再判断表达式是否成立。 清华大学软件学院

break和continue语句 break语句用来跳出循环体； continue语句用来结束本次循环； for(表达式1,表达式2,表达式3) { ...... if(表达式4) continue; } for(表达式1,表达式2,表达式3) { ...... if(表达式4) break; } 清华大学软件学院

循环体 表达式2 真 假 表达式1 表达式3 循环体 表达式2 真 假 表达式1 表达式3 break continue 清华大学软件学院

运行结果为： i=0 i=1 ********** #include <iostream.h> int main( ) { int i; for(i=0;i<4;i++) if (i==2) break; else cout<<"i="<<i<<endl; cout<<"**********"<<endl; return 0; } 运行结果为： i=0 i=1 ********** 清华大学软件学院

运行结果为： i=0 i=1 i=3 ********** #include <iostream.h> int main( ) { int i; for(i=0;i<4;i++) if (i==2) continue; else cout<<"i="<<i<<endl; cout<<"**********"<<endl; return 0; } 运行结果为： i=0 i=1 i=3 ********** 清华大学软件学院

程序举例 例子1：谁做的好事？ 清华附中有四位同学中的一位做了好事，不留名，表扬信来了之后，校长问这四位是谁做的好事。 A说：不是我。 B说：是C。 C说：是D。 D说：C胡说。 已知三个人说的是真话，一个人说的是假话。 现在要根据这些信息，找出做了好事的人。 清华大学软件学院

首先把四个人说的四句话写成关系表达式。在声明变量时，让thisman表示要找的人，定义为字符变量： char thisman 令“==”的含义为“是”，“!=”的含义为“不是” A说：不是我。－> (thisman != ‘A’) B说：是C。 －> (thisman == ‘C’) C说：是D。 －>(thisman == ‘D’) D说： C胡说。－>(thisman != ‘D’) 清华大学软件学院

思路：如何找到该人，一定是“先假设该人是做好事者，然后到每句话中去测试看有几句是真话”。“有三句是真话就确定是该人，否则换下一人再试”。 比如，先假定是A同学，让thisman='A';代入到四句话中 清华大学软件学院

先假定是A同学，让thisman='A';代入到四句话中： A：thisman!='A'; 'A'!='A' 假，值为0。 B：thisman=='C'; 'A'=='C' 假，值为0。 C：thisman=='D'; 'A'=='D' 假，值为0。 D：thisman!='D'; 'A'!='D' 真，值为1。 显然，不是'A'做的好事 （四个关系表达式值的和为1） 清华大学软件学院

再试B同学，让thisman='B'，代入到四句话中： A：thisman!='A'; 'B'!='A' 真，值为1。 B：thisman=='C'; 'B'=='C' 假，值为0。 C：thisman=='D'; 'B'=='D' 假，值为0。 D：thisman!='D'; 'B'!='D' 真，值为1。 显然，不是'B'所为 （四个关系表达式值的和为2） 清华大学软件学院

再试C同学，让thisman='C'，代入到四句话中： A：thisman!='A'; 'C'!='A' 真，值为1。 B：thisman=='C'; 'C'=='C' 真，值为1。 C：thisman=='D'; 'C'=='D' 假，值为0。 D：thisman!='D'; 'C'!='D' 真，值为1。 显然，就是'C'做了好事（四个关系表达式值之和为3） 这时，我们可以理出头绪，要用枚举法，一个人一个人地去试，四句话中有三句为真，该人即所求。 清华大学软件学院

从编写程序的角度看，实现枚举最好用循环结构 // thisman 分别赋值为‘A’, ‘B’, ‘C’, ‘D’ int sum; for(char thisman = ‘A’; thisman <= ‘D’; thisman++) { sum = (thisman != ‘A’) // ‘A’的话是否为真 + (thisman == ‘C’) // ‘B’的话是否为真 + (thisman == ‘D’) // ‘C’的话是否为真 + (thisman != ‘D’); // ‘D’的话是否为真 if (sum == 3) { cout << “This man is ” << thisman << endl; break; } } 清华大学软件学院

例子2：案件分析 某刑侦大队就涉及六个嫌疑人的疑案进行分析： A、B至少有一人作案； A、E、F三人中有两人参与作案； A、D不可能是同案犯； B、C或同时作案，或与本案无关； C、D中有且仅有一人作案； 如果D没有参与作案，则E也不可能参与作案。 试编一程序，将作案人找出来。 清华大学软件学院

思路：将案情的每一条线索写成逻辑表达式，第一条用 CC1表示，第二条用CC2表示，…… CC1: A、B至少有一人参与该案件 令变量A表示A是否参与该案件，A＝{0,1} 变量B表示B是否参与该案件，B＝{0,1}； A B CC1 0 0 0 1 0 1 0 1 1 1 1 1 CC1 = (A || B) 清华大学软件学院

这三者是或的关系，因此有： CC2 ＝ (A && (!D)) || (D && (!A)) || ((!A) && (!D)) A是案犯，D不是案犯，写成 A &&(!D) D是案犯，A不是案犯，写成 D &&(!A) A、D都不是案犯，写成 (!A) && (!D) 这三者是或的关系，因此有： CC2 ＝ (A && (!D)) || (D && (!A)) || ((!A) && (!D)) 等价于： CC2 ＝ !(A && D) ＝ (!A || !D) 清华大学软件学院

CC3: A、E、F三人中有两人参与该案件。有三种可能： 1) A和E参与，F不参与：A && E &&(!F) 2) A和F参与，E不参与：A && F &&(!E) 3) E和F参与，A不参与：E && F &&(!A) 这三者是或的关系，因此有： CC3 ＝ (A && E && (!F)) || (A && F && (!E)) || (E && F && (!A)) 清华大学软件学院

CC3 的真值表 A E F A&&E&&(!F) A&&F&&(!E) E&&F&&(!A) CC3 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1 1 0 1 0 0 1 1 0 1 0 1 0 1 0 1 1 0 0 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 清华大学软件学院

CC4: B、C或同时参与，或与本案无关，分析有两种可能： 1) 同时参与： B && C 2) 都与本案无关： !B && !C 这两者是或的关系，因此有： CC4 ＝ (B && C) || (!B && !C) CC5: C、D中有且仅有一人参与该案件，可分析为： CC5 ＝ (C && !D) || (D && !C) 清华大学软件学院

CC6:如果D没有参与该案件，则E也不可能参与。 这是一种蕴涵关系，可写成：!D  !E 蕴涵关系的规律是 PQ等价于 !P || Q， 因此上式等价于： CC6 ＝ D || !E 清华大学软件学院

6个人每个人都有作案或不作案两种可能，因此有26种组合，从这些组合中挑出符合6条分析的作案者。 采取枚举方法 6个人每个人都有作案或不作案两种可能，因此有26种组合，从这些组合中挑出符合6条分析的作案者。 定义6个整数变量，A，B，C，D，E，F，分别表示6个人。 枚举每个人的可能性 {0，1} 让0表示不是罪犯； 让1表示就是罪犯。 清华大学软件学院

for(int A = 0; A <= 1; A++) for(int B = 0; B <= 1; B++) for(int C = 0; C <= 1; C++) for(int D = 0; D <= 1; D++) for(int E = 0; E <= 1; E++) for(int F = 0; F <= 1; F++) { CC1 = A || B; CC2 = !A || !D; CC3 = (A && E && !F) || (A && F && !E) || (E && F && !A); CC4 = (B && C) || (!B && !C); CC5 = (C && !D) || (D && !C); CC6 = D || !E; if(CC1 + CC2 + CC3 + CC4 + CC5 + CC6 == 6) cout<<"犯罪嫌疑人是：" << (A ? 'A' : ' ') << (B ? 'B' : ' ') << (C ? 'C' : ' ') << (D ? 'D' : ' ') << (E ? 'E' : ' ') << (F ? 'F' : ' ') << endl; } 清华大学软件学院

输出：犯罪嫌疑人是：A B C F 验证： A、B至少有一人参与该案件； A、D不可能是同案犯； A、E、F三人中有两人参与该案件； C、D中有且仅有一人参与该案件； 如果D没有参与该案件，则E也不可能参与。 清华大学软件学院

例子3 例子3：求100以内的所有质数 问题分析： 对100以内的每一个整数，判断其是否为质数； 判断整数m是否为质数的方法：让 m 被 2 到 除，如果 m 能被其中的任何一个整数整除，则说明它不是一个质数；否则的话，说明它是一个质数。 清华大学软件学院

// 求100以内的所有质数。 #include <stdio. h> #include <math // 求100以内的所有质数。 #include <stdio.h> #include <math.h> main( ) { int i, j, sq, num; num = 0; for(i = 2; i <= 100; i++) { sq = sqrt(i); for(j = 2; j <= sq; j++) { if(i % j == 0) break; } if(j > sq) { printf("%2d ", i); num ++; if(num % 10 == 0) printf("\n"); } } } 清华大学软件学院

程序输出： 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 清华大学软件学院

第二周实验 题目见文件“第二讲习题.pdf” 要求： 独立完成； 本周五晚上10：00之前提交到服务器上； 清华大学软件学院