第二章 基本数据类型及运算 数据类型 常量与变量 不同类型数据间的转换 运算符和表达式

例2.1 编写程序，输入学生的学号、某课程的平时成绩、实验成绩和期末考试成绩；根据各成绩所占比例，求解并输出学生的该课程总成绩。 注释 ///********************************************************** /// 程 序 名：2_1.cpp * /// 主要功能： * /// 输入某学生的学号和《C语言程序设计》课程的平时成绩、 * /// 实验成绩和期末成绩，并根据各成绩所占比例， * /// 计算出这门课程的总成绩并输出到屏幕 * #include <stdio.h> #include <iostream> using namespace std; // 引用标准命名空间 int main() { …… return 0; } 此语句和int 呼应

{ const double USUAL_TEST_SCORE_RATIO = 0.3;//常量，平时成绩占总成绩的比率：% const double EXPERIMENT_SCORE_RATIO = 0.2 const double FINAL_EXAM_SCORE_RATIO = 0.5 int studentID; // 变量，存放学生的学号 double usualTestScore; // 变量，存放课程的平时成绩 double experimentScore; // 变量，存放课程的实验成绩 double finalExamScore; // 变量，存放课程的期末成绩 double termScore; // 变量，存放课程的学期总成绩 …… } 数据类型 常量 变量

常量、变量、标识符

常量 常量就是在程序使用之前预先设定并在整个运行过程中没有变化的量。 C语言有两种实现常量的方法： 直接常量和符号常量

变量 变量是在程序执行过程中其值可以改变的量。 在程序中需要先定义变量，再使用变量。 定义变量包含两个步骤： ① 指出变量的数据类型。 例如： int studentID; //int是变量的数据类型 ② 为每个变量取一个名称（变量名）。 int studentID; //studentID是变量名

Ｃ语言允许把数据存放在变量中，每一个变量都由一个变量名来标识。变量名的命名规则要满足标识符的规定。 每个变量都必须具有一个类型。 每个变量根据它的类型，在内存中占据一 定数目的字节单元，该变量的值就存放在 这些内存单元中。

变量 变量的本质就是命名的内存单元 变量名 prod 实际上是一个符号地址 内存单元的地址 prod 123 123是 prod的值 内存单元的内容 变量的本质就是命名的内存单元

标识符 标识符即用来标识变量名、符号常量名、函数名、数组名、类型名、文件名的有效字符序列。

标识符的命名规定 只能由大小写字母、下划线和数字组成； 开头的第一个字符只能是大小写字母或 下划线； 大小写是敏感的； 不能与Ｃ的关键字重复； 名字在整个程序中必须是唯一的； 名字的长度不能超过系统的规定。

非法标识符的例子 非法的Ｃ标识符： 3rd_entry (数字开头) all$done (包含非法字符$) the end (包含空格) int (系统关键字)

2.2 基本数据类型

数据类型的概念 数据类型：数据存在的组织和形式。 程序中用到的所有数据都必须指定其数据 类型。

Ｃ的数据类型 整型 单精度型 基本类型 浮点型 双精度型 Ｃ的数据类型 字符型 数组类型 结构体类型 构造类型 联合类型 指针类型 枚举类型 数据类型决定： 1. 数据占内存字节数 2. 数据取值范围 3. 其上可进行的操作 指针类型 枚举类型 空类型

2.2.1 整型数据的常量与 变量

1. 整型数据类型

1. 整型数据类型 ◆ 有符号和无符号变量的区别是什么？ 有符号变量：变量中的最高位是符号位(0为正，1为负)，其余位是具体数值。因此可以表示负数和正数。 无符号变量：全部的位都是具体数值。因此只能表示正数。

2.整型常量 整型常量即整常数。 Ｃ中有下面三种形式的整型常量： 1. 十进制整型常量： 由数字0~9和正负号表示 如: 123, -456, 0

2. 整型常量 2.八进制整型常量： 由数字0开头,后跟数字0~7表示. 如： 0123, 即(0123)8 =(83)10 注意：八进制整型常量中不应出现“7”以上的数码。 如： 0128, 0209

2. 整型常量 3. 十六进制整型常量：以 “0x或0X”开头后跟0~9,a~f,A~F表示 如: 0xFF, 即(0xFF)16 =(255)10 问题： 0123 = ( )10 0x123 = ( )10 83 291 问题： 0123 = ( )10 0x123 = ( )10 0123=1*82+2*82+3*80 0x123=1*162+2*162+3*160=291

2. 整型常量--整型数据的存放 例如：short a=10; 内存中实际存放的是 +10 的补码 a 10 1 1 例如：unsigned short a=-10; 内存中实际存放的是 -10 的补码 a -10 1 输出a的值为：65526

2. 整型常量---为整型常量指定类型 在整常量后加字母l或L，指定数据是long 型常量，如879L，0x34fL。 在整常量后加字母u或U，认为它是unsigned int型常量, 如879u, 0743u, 0xFED8U。

3. 整型变量 变量定义的一般格式是： 类型 变量名； /* 注释 */ 定义整型变量 int i; // 定义变量i，系统为变量i分配4个字节的内存 int i, j, k; //定义i，j，k三个整型变量 注：Ｃ语言中的所有关键字都是小写的。

3. 整型变量 变量定义的一般格式是： 类型 变量名； /* 注释 */ 定义整型变量 int i; // 定义变量i，系统为变量i分配4个字节的内存 int i, j, k; //定义i，j，k三个整型变量 注：Ｃ语言中的所有关键字都是小写的。

3. 整型变量-----变量先定义后使用的好处 3. 整型变量-----变量先定义后使用的好处 #include <stdio.h> int main() { int a , b , sum ; a=123; b=456; sum=a+b; printf(“sum=%d\n”, sim); return 0; } 此处定义的变量名是 sum sim在这之前从未定义过，所以编译不能通过，且会出现错误信息。 Error：Undefined symbol 'sim'

3. 整型变量-----变量先定义后使用的好处 3. 整型变量-----变量先定义后使用的好处 #include <stdio.h> int main() { int a, re; float c; a=23; c=2.5; re= a%c ; printf(“余数=%d\n”, re); return 0; } 符号％是“求余”运算符，它要求参与运算的数据必须是整型的。而变量c却是实型的，所以编译也不能通过。 变量a是整型 变量c是实型 Error：Illegal use of floating point

4. 整型变量的初始化 C语言允许在定义变量的同时赋值，这称为变量初始化。 也可以给部分变量赋初值 int i = 0； 4. 整型变量的初始化 C语言允许在定义变量的同时赋值，这称为变量初始化。 int i = 0； long number = 12345; 也可以给部分变量赋初值 int i, j, k = 0;

4. 整型变量的初始化 变量在定义时值是不确定的。所以在变量初始化之前，不能让其参与运算，否则会得到不可预知的结果。 4. 整型变量的初始化 变量在定义时值是不确定的。所以在变量初始化之前，不能让其参与运算，否则会得到不可预知的结果。 int Total, Average; Total = Average * 40; Total和Average的值都是不确定的。

4. 整型变量的初始化 ◆ 可以在定义变量的同时进行初始化 如：int TotalStudent=40; 4. 整型变量的初始化 ◆ 可以在定义变量的同时进行初始化 如：int TotalStudent=40; 等价于：int TotalStudent; TotalStudent=40;

4. 整型变量的初始化 ◆定义多个变量时，可以对其全部或部分进行初始化 如： int TotalStudent=40, average, 4. 整型变量的初始化 ◆定义多个变量时，可以对其全部或部分进行初始化 如： int TotalStudent=40, average, TotalScore=0;

4. 整型变量的初始化 ◆不能用连续赋值方式给多个变量赋同一初值 如：int TotalScore = AverScore = 0; 4. 整型变量的初始化 ◆不能用连续赋值方式给多个变量赋同一初值 如：int TotalScore = AverScore = 0; 正确的应该是： int TotalScore=0, AverScore=0;

2.2.2 浮点型数据的常量与变量

1. 浮点型数据类型 1. 浮点型数据类型

2. 浮点型常量 实数又叫“浮点数”。 C语言中，实数常量有两种表示形式： 十进制小数形式：由数字和小数点组成。 (小数点必须有) 如： 10.23, -0.456, .12, 0.0, 89.

2. 浮点型常量 指数形式：±s E ±n 或 ±s e ±n 形式。 注意： E或e前面必须有数字，后面的指数 必须为整数。

2. 浮点型常量----为浮点型常量指定类型 默认为double型。 在常量后加字母f或Ｆ，指定数据是float型常量。如 0.1234f

3. 浮点型变量 定义浮点型变量 float a; // 定义变量a，系统为它分配 4个字节的内存 double number; // 定义变量number， 系统为它分配8个字 节的内存

2.2.3 字符型数据的常量与变量

1. 字符型数据类型

1. 字符型数据类型----在内存中的存储方式 字符型数据在内存中占一个字节，该字节中保存的是其ASCII代码。 常用字符的ASCII 代码表 ASCII值 字符 NUL 48 65 A 97 a 10 LF 换行 49 1 66 B 98 b 13 CR 回车 … 32 空格 57 9 90 Z 122 z

2. 字符型常量 Ｃ语言中，字符常量是用单引号’ 括起来的一个字符，这些字符都是ASCII码集中的字符。 2. 字符型常量 Ｃ语言中，字符常量是用单引号’ 括起来的一个字符，这些字符都是ASCII码集中的字符。 比如：’a’ , ’A’ , ’d’ , ’D’ ,’?’ , ’%’ , ’$’ , ’2’ , ’4’ 注意： ’a’ 和 ’A’ ， ’d’ 和 ’D’ 都是不 同的字符常量。

2. 字符型常量----转义字符常量 另外：Ｃ语言还存在转义字符常量。 它以 \ 字符开头，后面跟一个字符或代码值，并用单引号括起来。 2. 字符型常量----转义字符常量 另外：Ｃ语言还存在转义字符常量。 它以 \ 字符开头，后面跟一个字符或代码值，并用单引号括起来。 比如： ’\n’ , ‘\t’ , ‘\r’ , ‘\\’

2. 字符型常量----转义字符常量及其含义 转义字符 含义 ASCII 代码 控 制 字 符 \n 回车换行(光标移到下一行第一列) 10 2. 字符型常量----转义字符常量及其含义 转义字符 含义 ASCII 代码 控 制 字 符 \n 回车换行(光标移到下一行第一列) 10 \t 水平制表 (光标移到下一个Tab位置) 9 \b 退格(光标移回到同一行前一列) 8 \r 回车(光标移到同一行第一列) 13 \f 换页(光标移到下一页开头) 12

2. 字符型常量----转义字符常量及其含义 转义字符 含义 ASCII 代码 \ddd 2. 字符型常量----转义字符常量及其含义 转义字符 含义 ASCII 代码 \ddd ddd为1至3位八进制数字构成,表示对应的ASCII码的字符 \xdd dd为1至2位十六进制数字构成,表示对应的ASCII码的字符 特殊标点符号 \\ 反斜杠字符 “\” 92 \‘ 单引号(撇号)字符 ‘ 39 \“ 双引号字符 “ 34 如 ’\101’ ------ ’A’ ’\012’ ----’\n’ ’\376’ -----’’ ’\x61’ ----’a’ ’\60’ -----’0’ ’\483’ --- () 例5：(程序） ’A’--’\101’---’\x41’----65 举例: char a; a=‘A’; a=65;

2. 字符型常量----字符型数据在内存中的存储方式 2. 字符型常量----字符型数据在内存中的存储方式 ASCII 值＝65 ’Ａ’ 65 1 这个字节存储的内容是01000001。 如果它以整型的格式输出，则输出65； 如果它以字符型格式输出，则输出A。

3. 字符型变量 定义型变量 char a; // 定义变量a，系统为它分配1 个字节的内存 a='a'; // 把'a'常量赋值到a变量中

3. 字符型变量---整型数据和字符型数据通用 3. 字符型变量---整型数据和字符型数据通用 字符型数据存储对应的 ASCII 码，和整型数据在一定范围内可以通用，即可以相互赋值，相互输出，也可以在一起进行运算。 “一定范围内” 指的是“一个字节”所能保存的整数范围内。 char linefeed = 65; char linefeed = 'A';

2.2.4 字符串常量

2.2.4 字符串常量 Ｃ语言中，字符串常量是用双引号’ ’ 括起来的若干个字符。 比如：’’a” , ”A” , ”hello” , ”OK” , ”SiChuanDaXue” ◆字符串常量在内存中占用连续的字节单元，每个字符按顺序占一个字节。 系统自动在字符串常量的结尾加一个字符串结束标志字符， 表示字符串结束。

2.2.4 字符串常量---字符串结束标志字符 Ｃ语言中，字符串结束标志字符是 ’\0’ 。 ◆ ’\0’ 是ASCII码为0的字符。它是一个“空操作字符”，它既不引起任何控制动作，也不产生任何显示。 ◆ 因此，字符串常量在内存中占用的字节数等于可见字符数加上1。

字符串结束标志字符也是一个字符，也要占用一个字节。 2.2.4 字符串常量---字符串结束标志字符 字符串结束标志字符也是一个字符，也要占用一个字节。 5个可见字符 H E L O \0 ” HELLO ” 总共占用6个字节 没有字符串变量，字符串用字符数组存放。

2.2.4 字符串常量---’A’和”A”的区别 ’A’ 是字符常量，占一个字节单元 ”A” 是字符串常量，占两个字节单元， 包括’ A’和’\0’两个字符 ◆不能把一个字符串常量赋值给一个字符变量。 如 char c1 = ”A” ; 是错误的。

2.2.5 符号常量

常量的三种形式---直接常量 1. 在程序中直接使用数值 例如，课程的期末成绩占总成绩的比例是0.5，使用直接常量，求解课程总成绩的语句可以写成： termScore= usualTestScore*0.3 + experimentScore*0.2 + finalExamScore*0.5;

常量的三种形式---const 2. 用const关键字把一个变量声明转换成常量声明 例如，用常变量PI存储π的值 const double PI = 3.14159;

常量的三种形式---宏定义 3.采用宏定义形式定义符号常量 例如，用常变量PI存储π的值 const double PI = 3.14159;

常量的三种形式---宏定义 宏定义符号常量：用一个标识符代表一个常量 实现方式： #define 标识符 字符串 它的作用是：程序中的标识符用其后的字符串替换。

符号常量的实现 常量的三种形式---宏定义 这个字符串将要在预处理时去替换符号PI 一般用大写，PI会被指定的字符串3.14159代替 #define PI 3.14159 int main() { float r, c, s, v; r=20; c=2*PI*r; printf(“周长=%f\n”, c); s=PI*r*r; printf(“面积=%f\n”, s); v=4*PI*r *r *r/3; printf(“体积=%f\n”, v); return 0; } 一般用大写，PI会被指定的字符串3.14159代替

常量的三种形式---宏定义 注意事项：符号常量不是变量，不能被赋值。 这样的赋值是错误的 #define PI 3.14159 int main() { …… PI = 100; } 这样的赋值是错误的

常量的三种形式---宏定义 注意事项：如果指定的符号出现在双引号中，就不被替换。 是预处理命令，不是C语句 这个PI不会被替换 #define PI 3.14159 int main() { …… printf(“PI = %f”, PI); } 这个PI不会被替换 这个PI会被替换

2.3 运算符与表达式

2.3.1 运算符与表达式概述

1.运算符 运算符：一些特定的符号,具有特定的运算功能. 例如: 算术运算（加、减、乘、除） 比较运算（大于、小于、等于） 逻辑运算（与、或、非） Ｃ语言共有３４种运算符。

1.运算符 学习运算符应注意： 运算符功能 与运算量关系 要求运算量个数 要求运算量类型 运算符优先级别 结合方向 结果的类型

2.表达式和表达式语句 表达式：按照运算符的性质，用运算符把数据连接起来以达到运算目的的式子。 每一个表达式都会有一个运算的结果，称为表达式的值。一个表达式中往往包含多个运算符，所以必须熟悉每一种运算符的性质(优先级别和结合性)，才能写出正确的表达式。 在表达式的末尾加上一个分号“;”就构成了表达式语句。

2.3.2 算术运算符和算术表达式

1. 基本的算术运算符 ◆算术运算符（双目）： ＋ 加 － 减 * 乘 / 除 ％ 求余 ＋ 加 － 减 * 乘 / 除 ％ 求余 如：20*4 ； 10-3+5*2-8%9/3 ； 3%5

1. 基本的算术运算符---算术运算符的说明 说明： “-”可为单目运算符时,右结合性 两整数相除，结果为整数 %要求两侧均为整型数据，其结果的符号与左边数据的符号相同。

1. 基本的算术运算符---例 例 -5/2.0 = -2.5 例 -5%2 = -1 5.5%2 () #include <stdio.h> int main( ) { int a=3, b=5, c=0; c = a/b; printf(“c=%d\n”, c); 　 c = b/a; return 0; } 例 -5/2.0 = -2.5 例 -5%2 = -1 5.5%2 ()

2. 算术运算的优先级与结合性 算术运算符的优先级： *、/、％ 同级 ＋、－ 同级 高 低 算术运算符的结合性： 自左向右 参考课本的附录 Ｃ语言全部34种运算符的性质以及 优先级和结合性。

2. 算术运算的优先级与结合性--优先级和结合性的概念 首先表达式里运算符优先级高的先执行，如果在一个运算对象两侧的运算符的优先级别相同，则按运算符的结合性处理。

2. 算术运算的优先级与结合性--优先级和结合性的概念 10 - 3 + 5 * 2 - 8 % 9 / 3 10 - 3 + (5 * 2) – (8 % 9 / 3) 10 - 3 + 10 – (8 % 9 / 3) 10 - 3 + 10 – ( 8 / 3) - 3 + 10 – 2 7 + 10 – 2 17 – 2 15

3. 自增、自减运算符 ◆自增、自减运算符（单目） 运算符： ＋＋ －－ 优先级： 高于算术运算符 结合性： 右结合性 运算符： ＋＋ －－ 优先级： 高于算术运算符 结合性： 右结合性 作 用： 使变量的值加１或减１

? 3. 自增、自减运算符 ◆用法：设i是个整型变量， ++i -- i (运算符前置) i++ i -- (运算符后置) 两种用法的区别？

3. 自增、自减运算符：例 运行结果：a=6, m=6 a=5, m=6 a=6, m=5 a=6, m=6 #include <stdio.h> int main( ) { int a = 5, m; m = ++ a; printf("a=%d, m=%d\n", a, m); m = a - -; ++ a; m - -; printf("a=%d, m=%d\n", a - -, ++ m ); }

? 3. 自增、自减运算符----使用注意事项 注意：自增、自减运算符的运算量只能 是变量，不可能是常量或表达式。 为什么？ 因为自增、自减运算符有赋值功能，常量和表达式不能被赋值。 ++ i i = i + 1 - - i i = i - 1 像下面这样的用法就是错误的： ++ 10 (x+y) ++

2.3.3 赋值运算符和赋值表达式

1. 赋值运算符的功能、优先级和结合性 ◆赋值运算符（双目） 运算符： ＝ 优先级： 低于算术运算符。 结合性： 右结合性 作 用：将一个数据赋值给一个变量， 这个数据可以是常量、变量或 表达式。

1. 赋值运算符的功能、优先级和结合性 ◆赋值表达式一般形式： 变量＝表达式 如：num=40 把常量40赋值给变量num 如：aver=total/num 把表达式total/num的值赋给变量aver 如：temp=aver 把变量aver的值赋给变量temp

3. 赋值运算符的使用--- （1）赋值运算符左边的量 注意：赋值表达式的左边只能是变量， 而右边可以是常量、变量或任何合法的 Ｃ表达式。 像下面这样的用法就是错误的： 10 = x x+y = 1 整个赋值表达式的值就等于赋值后的左边变量的值。

3. 赋值运算符的使用--- （2）赋值运算参与表达式运算的过程 #include <stdio.h> int main( ) { int a, b, c; /* int a = b = c = 10; */ a = b = c = 10; printf(“a=%d, b=%d, c=%d\n”, a, b, c); /* c = ( a * 3 ) = b; */ c = ( a = 3 ) * b; } 运行结果： a=10, b=10, c=10 a=3, b=10, c=30

3. 赋值运算符的使用--- （3）赋值表达式结果的类型 规则：赋值号右边表达式值自动转换成左边变量的类型 例 int i; i=2.56; //结果i=2; 例 float f; int i; i=10; f=i; //结果 f=10.0

3. 赋值运算符的使用--- （4）复合赋值运算符 ◆复合赋值运算符（双目） 运算符： += -= *= /= %= &= ^= |= <<= >>= 在赋值运算符之前再加上其它运算符(包括5种算术运算符和5种位运算符)，即构成复合赋值运算符。优先级和结合性与赋值运算符相同。

3. 赋值运算符的使用--- （4）复合赋值运算符 相当于 a+=3 a=a+3 相当于 x%=y+8 x%=(y+8) x=x%(y+8) 不相当于 x= x%y+8

2.3.4 关系运算符和关系表达式

1. 关系运算符的功能 ◆关系运算符（双目）：也叫“比较运算符” 6种： < 小于 <= 小于等于 6种： < 小于 <= 小于等于 > 大于 >= 大于等于 == 等于 != 不等于 ◆关系表达式的运算量可以是常量、变量或任何合法的表达式。 如：a*a <= 100 如：NowIndex == MaxIndex

<、<=、>、>= 同级 2. 关系运算符的优先级和结合性 关系运算符的优先级： <、<=、>、>= 同级 ==、!= 同级 高 低 算术运算符 = 赋值运算符 关系运算符的结合性： 自左向右

3. 关系运算符使用的注意事项-- （1）关系运算符使用左右操作数的算数运算值 ◆每一个表达式都有一个算术运算值和一个逻辑值。 所谓算术运算值，即表达式的运算结果。 所谓逻辑值，规则是：非0的算术运算值其逻辑值是1；0的逻辑值为0。表示“真”或“假”

3. 关系运算符使用的注意事项-- （1）关系运算符使用左右操作数的算数运算值 ◆关系运算符在比较左右表达式的值的大小时，使用左右操作数的算数运算值，而不是逻辑值。 但关系运算的值是“逻辑值”，表示“真”或“假”，而且 “真”用整数1表示； “假”则得到整数0。

3. 关系运算符使用的注意事项-- （2）关系运算符参与复杂表达式的计算 void main( ) { int a=3, b=2, c=1, d; printf(“%d\n”, a > b); d = b < c; printf(“%d\n”, d); d = a == b + c; d = a > b > c; return ; } 运行结果： 1 0 1 0

3. 关系运算符使用的注意事项-- （3）==与=的区别 = 是“赋值运算符”。赋值表达式中，赋值 运算符的左边只能是变量。 == 是“等于关系运算符”。关系表达式中，运算符的两边可以是常量、变量或任何合法的表达式。

3. 关系运算符使用的注意事项-- （3）==与=的区别 (a = 1)==(b = 2) 是正确的关系表达式 (a = 1) = (b = 2) 是错误的赋值表达式 假设a = 1，则： a = 2 这个赋值表达式的值是2 a == 2 这个关系表达式的值是 0

2.3.5 逻辑运算符和逻辑表达式

1. 逻辑运算符的功能 逻辑运算符：3种 && 逻辑与(双目) || 逻辑或(双目) ! 逻辑非(单目)

? 1. 逻辑运算符的功能-- &&逻辑与 &&逻辑与： 全部运算量的逻辑值都为1，逻辑与运算才为1； 只要有一个运算量为0，逻辑与运算即为0 例： 要求写一个表达式，判断变量x的值是否在 （-5，+5）范围内。 考虑x=-6 数学上的表达：-5 < x < +5 ? C语言中的表达：

1. 逻辑运算符的功能-- &&逻辑与 例如： 当x=6时 在C语言中用-5 < x < +5判断， 结果是：1。 表示“成立”。 判断错误。 应该这样使用： x > -5 x < +5 && -5 +5

1. 逻辑运算符的功能-- || 逻辑或 || 逻辑或： 全部运算量的逻辑值都为0，逻辑或运算才为0； 只要有一个运算量逻辑值为1，逻辑或运算即为1 x < -5 x > +5 || -5 +5

1. 逻辑运算符的功能-- ! 逻辑非： ! 逻辑非： 运算量的逻辑值为1 ，逻辑非运算则为0； 运算量的逻辑值为0 ，逻辑非运算则为1 1. 逻辑运算符的功能-- ! 逻辑非： ! 逻辑非： 运算量的逻辑值为1 ，逻辑非运算则为0； 运算量的逻辑值为0 ，逻辑非运算则为1 x < 0 ! (x > =0)

2. 逻辑运算符的优先级和结合性 逻辑运算符的优先级： 逻辑运算符的结合性： 关系运算符 && 逻辑与 高 低 算术运算符 || 逻辑或 ! 逻辑非 = 赋值运算符 逻辑运算符的结合性： && 、|| 自左向右 ! 自右向左

3. 逻辑运算符使用的注意事项--（1）逻辑运算符使用左右操作数的逻辑值 逻辑运算的运算量：可以是任何类型的数 据。既可以使常量、变量，也可以是表达式。 ◆逻辑运算符两边的运算量都使用表达式的逻辑值，即“0”或“1”。 逻辑表达式的运算结果也是逻辑值：0 或 1 如：x && y + z 如：5 && 3 && ! 0 结果：1

3. 逻辑运算符使用的注意事项--（2）逻辑运算符参与复杂表达式的计算 逻辑运算的运算量：可以是任何类型的数 据。既可以使常量、变量，也可以是表达式。 ◆逻辑运算符两边的运算量都使用表达式的逻辑值，即“0”或“1”。 逻辑表达式的运算结果也是逻辑值：0 或 1 如：x && y + z 如：5 && 3 && ! 0 结果：1

((a+b)>c)&&(b==c) (7>c) && (b==c) 1 && (b==c) 1 && 0 → 0 3. 逻辑运算符使用的注意事项--（2）逻辑运算符参与复杂表达式的计算 逻辑表达式：例 void main( ) { int a = 3, b = 4, c = 5, d = 0, x = 0, y = 0; d = a + b > c && b == c; printf(“%d\n”, d); return ; } ((a+b)>c)&&(b==c) (7>c) && (b==c) 1 && (b==c) 1 && 0 → 0 输出0

3. 逻辑运算符使用的注意事项--（3）短路特性 对于“&&”表达式和“||”表达式，系统按从左向右顺序求解时，如果当求出某个运算量后整个逻辑表达式的值就能够确定时，则余下的运算量不被求解。

3. 逻辑运算符使用的注意事项--（3）短路特性 x < -5 || x > +5 假设： x = -6 1 || x < +5 没有被求解 1 x > -5 && x < +5 假设： x = -6 0 && x < +5 没有被求解

3. 逻辑运算符使用的注意事项--（3）短路特性 void main( ) { int a = 3, b = 4, c = 5, d = 0, x = 0, y = 0; d = a + b > c && b == c; printf(“ %d\n”, d); d = a ++ | | c ++; printf(“%d\n”, d); d = ! (x = a) && (y = b); printf(“a = %d, c = %d\n”, a, c); printf(“x = %d, y = %d\n”, x, y); return ; } 运行结果： 1 a=4, c=5 x=4, y=0

2.3.6 逗号运算符和逗号表达式

1. 逗号运算符的功能、优先级和结合性 ◆逗号运算符（多目） 运算符： ， 用 法： 表达式1，表达式2，表达式3， ……，表达式n 用 法： 表达式1，表达式2，表达式3， ……，表达式n 优先级： 整个运算符优先级表中最低的 结合性： 自左向右 作 用： 用逗号把若干表达式连接起来，系统依次求解每个表达式，其值就等于最后那个表达式的值。

1. 逗号运算符的功能、优先级和结合性---例 i=1, j=1, sum=0 逗号表达式：由3个赋值表达式构成 1, 1, 0 依次求解3个赋值表达式的值 逗号表达式的值是最后那个赋值表达式的值。这个值往往不被使用。 //a=15,表达式值20 例：a=3*5,a*4,a+5

2. 逗号运算符使用的注意事项--（1）逗号运算符参与复杂表达式的运算 #include <stdio.h> void main( ) { int x, b; x = 0, b = 0 ; x = ( b = 3, 2 * b ) ; printf(“%d, %d\n”, x, b); x = b = 3, 2 * b ; } 是逗号表达式。 运行结果： 6, 3 3, 3

2.4 混合运算与类型转换

2.4.1 自动类型转换 ◆不同类型的数值型数据之间可以进行混合运算。如：10+‘a’+1.5*123.45*’B’ ◆系统在求解时，先自动把不同类型的数据转换成同一类型，然后进行运算。转换规则如图： double long unsigned int float char, short 高 低 运算对象不同时转换 必定的转换

2.4.2 强制类型转换 ◆强制类型转换运算符（单目） 运算符： (类型名) 用 法： (类型名) (变量或表达式) 用　法： (类型名) (变量或表达式) 优先级： 高于算术运算符 结合性： 右结合性 如：(long)(length-200) 如：(float)5/3 相当于：((float)5)/3

2.4.2 强制类型转换 注意：参与强制 类型转换的变量 本身的类型并不 会改变。 #include <stdio.h> int main( ) { 　 float a = 3.5, b = 2.3; int c; 　 c = (int) a - (int) b ; printf(“c=%d\n”, c); 　 c = (int) a % c ; return 0; } 注意：参与强制 类型转换的变量 本身的类型并不 会改变。

2.4.3 赋值运算中的类型转换 赋值运算中左右操作数数据类型不一致时，自动类型转换的原则是： 将运算符右边的值的类型转换成与左边变量的类型一致。

2.5 数据的输入输出

2.5.1 使用cin和cout进行数据输入输出 cin是C++的标准输入流对象， cout是C++的标准输出流对象， 它们都在头文件iostream中定义。 因此使用这两个流对象需要加载这个头文件。

1. 输出流对象cout cout是C++的标准输出流，用于在屏幕上显示插入的字符。 例如： cout << "Good Morning!\n"; cout和输出运算符<<一起使用，<<的作用是将字符串“Good Morning!\n”写入到输出流cout中，也就是输出在标准输出设备（通常是屏幕）上。

1. 输出流对象cout---例 int studentID = 12345678; float score = 98.5; 输出结果为： studentID=12345678, score=98.5, grade=A int studentID = 12345678; float score = 98.5; char grade = 'A'; cout << "studentID=" << studentID << ", score=" << score << ", grade=" <<grade <<endl; 将多个数据写入到输出流cout中 控制符endl代表回车换行操作

2. 输入流对象cin cin是C++的标准输入流对象。用于从键盘输入信息至内存变量。 例如： int studentID; float score; cin >> studentID >> score; // 输入一个整数和浮点数。 输入：12345678 98.5 (数据间用空格分隔) 用cin输入变量时，C语言会自动识别变量的类型，将输入的字符转换成合适的数值传给变量。

2.5.2 单个字符的输入输出

1. 字符输出函数putchar() putchar()函数的功能：向标准输出设备（一般是屏幕）输出一个字符。 它需要一个字符型的参数（参数可以是常量、变量或表达式）。它的一般形式是： putchar(字符型数据);

1. 字符输出函数putchar()---例 运行结果： BOY Ab #include <stdio.h> void main( ) { char a, b; int c, d; a = 'B'; b = 'O'; c = 65; d = 66; putchar(a); putchar(b); putchar('Y'); putchar(‘\n’); putchar(c); putchar(d+32); } 运行结果： BOY Ab

2. 字符输入函数getchar() getchar()函数的功能是从键盘获得一个字符，并将这个字符作为函数的返回结果，返回给调用它的程序。

2. 字符输入函数getchar() --执行过程 函数调用的语句时，会暂时停下来，此时 屏幕上有一个闪烁的光标，等待用户从键 盘上的输入。用户必须键入有关信息并按 Enter键后程序才能继续向下执行。

2. 字符输入函数getchar()—例 字符输入函数getchar ：例 运行结果： B↙ (用户键入字 符B后，再键入“回 车”键) B (putchar函数再在屏幕上输出一个字符B) #include <stdio.h> void main( ) { char ch; ch = getchar( ); putchar(ch); }

2.5.3 数据的格式化输出

printf(格式控制字符串，输出数据列表); 功能：一次函数调用可以在显示器上输出多个不同类型的数据,这些数据以指定的格式输出。 printf()函数的一般格式为： printf(格式控制字符串，输出数据列表);

printf(格式控制字符串，输出数据列表); ⒈ 格式控制字符串：通常是字符串常量。 ⒉ 输出数据列表：将需要输出的多个数据顺序排列，用逗号分隔。数据可以是常量，变量、函数调用或任何合法的C表达式。

1.格式输出函数printf 例： 输出数据列表 格式控制字符串 函数名 三个参数 int num = 15; printf(“Twice %d is %d .\n” , num, 2*num); 输出数据列表 格式控制字符串 函数名 三个参数

1. 格式输出函数printf() 格式控制字符串中通常包含两类字符： 格式控制字符：由％和规定的格式字符组成。 如： ％d ％c ％f 作用： 输出列表中对应位置上的数据以该格式字符所规定的数据类型输出。 例如：%d 表示对应的数据以整型的格式输出。

1. 格式输出函数printf() 普通字符：除格式字符以外的所有其它字符。

1. 格式输出函数printf() 函数执行过程： 普通字符：原样输出 格式字符：格式化要输出的数据 int num = 15; printf(“Twice %d is %d .\n” , num, 2*num); 普通字符 格式字符 普通字符 格式字符 普通字符 待输出的数据 Twice 15 is 30 . _ 普通字符：原样输出 格式字符：格式化要输出的数据

2. printf()中常用的格式字符和附加修饰符 格式作用 整型 d, i 格式化为有符号的十进制整数 u 格式化为无符号的十进制整数 o 格式化为无符号的八进制整数 x, X 格式化为无符号的十六进制整数 字符型 c 格式化为一个字符 s 格式化为一个字符串

2. printf()中常用的格式字符和附加修饰符 格式作用 实型 f 格式化为小数形式的实数，隐含输出6 位小数 e, E 格式化为指数形式的实数，数字部分有 6位小数 g, G 选用％f或％e格式中输出宽度较短的一 种格式，不输出无意义的0

2. printf()中常用的格式字符和附加修饰符 在格式说明时，还可以在％和上述格式 字符之间插入几种附加的修饰符。 % [-][m][.n][l] 格式字符 例如： %-6.2f %5d

2. printf()中常用的格式字符和附加修饰符 附加 格式字符 格式作用 l 用于格式化长整型数据，可加在格 式符d、o、x、u的前面 m 用于确定数据输出时所占最小宽度,即列数 .n 对实型数，表示输出n位小数；对 字符串，表示截取的字符个数 - 向左对齐(默认是右对齐的)

3. 整型数据的输出---例 b 运行结果： #include <stdio.h> void main( ) { int b = -2; printf("b=%d,%o,%x,%u\n", b, b, b, b); }-- b 1 1 运行结果： b=-2, 37777777776， fffffffe, 4294967294

4. 浮点型数据的输出--例 #include <stdio.h> void main( ) { long c = 4000000; float f1 = 12345.67; printf("c = %ld, %d\n", c, c); printf("f1 = %f, %e\n", f1, f1); printf("f1 = %10.2f, %18.3e\n", f1, f1); } 运行结果： c = 4000000, 4000000 f1 = 12345.669922, 1.234567e+004 12345.67, 1.235e+004

5. 字符型数据的输出---例 #include <stdio.h> void main( ) { printf("%c%c%c", 'B', 'O', 'Y'); printf("%c", '\n'); printf("%s", "China"); printf("%s", "\n"); printf("Please input three data:"); } 运行结果： BOY China Please input three data:

printf函数使用中的注意事项 要分清哪些是格式字符，哪些是普通字符；同时也要注意区分普通字符中的转义字符常量。 如：%d 是格式字符，%D 不是格式字符 如：%cf 中%c是格式字符，f是普通字符 如：\n是转义字符，\a就不是转义字符

printf函数使用中的注意事项--转义字符 转义字符举例 main() { printf("\101 \x42 C\n"); printf("I say:\"How are you?\"\n"); printf("\\C Program\\\n"); printf("Turbo \'C\'"); }

printf函数使用中的注意事项 2. 输出数据的个数不能少于格式说明字符的个数；如果多于格式说明字符的个数，则多出的数据不被输出。 如： printf(“%d, %d\n”, a, b, c, d, e); 3. 用%%输出一个% 如： printf(“percent=%d%%\n”, pcn);

2.5.4 数据的格式化输入

1. 格式输入函数scanf() scanf()函数的一般格式为： 功能：读取用户从键盘上输入的数据，然后按照格式控制符的要求进行类型转换，并送到指定的内存单元中去。 scanf()函数的一般格式为： scanf(格式控制字符串, 地址列表);

scanf(格式控制字符串，地址列表); ⒈ 格式控制字符串：通常是字符串常量 ⒉ 地址列表：一些变量地址的列表，scanf 函数将把扫描的数据按顺序依次送到这些地址所指向的单元中去。

1. 格式输入函数scanf()--例 地址列表 格式控制字符串 函数名 三个参数 int num1, num2; scanf(“num1=%d ,num2=%d” , &num1, &num2); 地址列表 格式控制字符串 函数名 三个参数 功能：从键盘扫描用户的多个输入,并格式化这些数据,然后依次保存到指定的地址列表中。

1. 格式输入函数scanf() 格式控制字符串中可能包含两类字符： 格式控制字符：由％和规定的格式字符组成，一个字符串中可以有一个或多个格式控制字符。 如： ％d ％c ％f ％s 作用： 把用户输入的数据格式化成规定类型的数据。

1. 格式输入函数scanf() 普通字符：除格式字符以外的所有其它字符 它们不被显示，反而要求使用者在输入信息时照原样输入，否则函数将不能扫描到正确的数据。 因此，通常在格式字符串中，不要包含除逗号（约定俗成的分隔符）之外的任何字符。

1. 格式输入函数scanf() 取变量地址运算符& ◆ 取地址运算符（单目） 运算符： & 用 法： & 变量 用 法： & 变量 优先级： 处于整个运算符优先级表中的第 二级，高于所有的双目运算符 结合性： 自右向左 作 用： 得到变量的地址

1. 格式输入函数scanf() 注意：& 运算符的运算量只能是变量，不能取常量或表达式的地址。 如：int a; &a; /*取变量a的地址*/ &10 &(x+y)

1. 格式输入函数scanf() scanf（）函数的执行过程 普通字符：原样输入 格式字符：格式化扫描到的数据 15 30 int num1, num2; scanf(“num1=%d ,num2=%d” , &num1, &num2); 普通 字符 格式字符 普通 字符 格式字符 地址列表 num1 num2 num1= 15 ,num2= 30 ↙ 15 30 普通字符：原样输入 格式字符：格式化扫描到的数据

2. scanf()中常用的格式字符和附加修饰符 格式作用 整型 d, i 把扫描到的用户的输入格式化为有符 号的十进制整数 u 把扫描到的用户的输入格式化为无符 o 号的八进制整数 x, X 号的十六进制整数

2. scanf()中常用的格式字符和附加修饰符 格式作用 字符型 c 把扫描到的用户的输入格式化为一个 字符 s 字符串 实型 f 把扫描到的用户的输入格式化为实 数， 用户可以用小数形式或指数形式输入 e, E 与 f 的作用相同 g, G

2. scanf()中常用的格式字符和附加修饰符 在格式说明时，还可以在％和上述格式 字符之间插入几种附加的修饰符。 % [h][l][m][*] 格式字符 例如： %4d %*5d %lf

2. scanf()中常用的格式字符和附加修饰符 附加 格式字符 格式作用 h 用于d,o,x前，指定输入为short型整数 l 用于d,o,x前，指定输入为long型整数 用于e,f前，指定输入为double型实数 m 指定输入数据宽度，遇空格或不可转换字符则结束 * 抑制符，指定输入项读入后不赋给变量

scanf函数的使用：例 运行过程：11 a=17 a #include <stdio.h> void main( ) { int a; scanf(“%x”,&a); printf(“a=%d”,a); } 运行过程：11 a=17 a 1

scanf函数的使用：例 运行过程：19991015 yy=1999,mm=10,dd=15 #include <stdio.h> void main( ) { int yy, mm, dd; scanf(“%4d%2d%2d”,&yy,&mm,&dd); printf(“yy=%d, mm=%d, dd=%d”,yy,mm,dd); } 运行过程：19991015 yy=1999,mm=10,dd=15

scanf函数的使用：例 运行过程：12345678765.43 k=123,f=8765.429688 #include <stdio.h> void main( ) { int k; float f; scanf(“%3d%*4d%f”,&k,&f); printf(“k=%d, f=%f”,k,f); } 运行过程：12345678765.43 k=123,f=8765.429688

3. 使用scanf()函数应注意的问题 1. 第二部分参数是变量地址的列表，而不是变量的列表。 如：下面是正确的 scanf(“%d, %d”, &num1, &num2); 如：下面是错误的 scanf(“%d, %d”, num1, num2);

3. 使用scanf()函数应注意的问题 2. 一般以空格、TAB或换行符作为输入分隔符 例 scanf(“%d%o%x”,&a,&b,&c); printf(“a=%d,b=%d,c=%d\n”,a,b,c); 输入 123 123 123 输出 a=123,b=83,c=291 例 scanf(“%d:%d:%d”,&h,&m,&s); 输入 12:30:45 则12 h, 30 m, 45 s

3. 使用scanf()函数应注意的问题 3.用“%c”格式符时，空格和转义字符作为有效字符输入 如 scanf(“%c%c%c”,&c1,&c2,&c3); 若输入abc 则ac1, 空格 c2, b c3 4.输入数据时，遇以下情况认为该数据结束： 遇空格、TAB、或回车 ； 遇宽度结束 ； 遇非法输入 如scanf(“%d%c%f”,&a,&b,&c); 若输入1234a123o.26  则 1234 a, ‘a’ b, 123 c

2.6 顺序程序设计举例

程序开发的过程 用计算机解决问题的过程大致是： 1.分析问题，首先从数学上找出解决该问题的方法（数学模型，公式） 2.拟出具体的解决步骤（算法，流程图） 3.用某种计算机语言实现（程序设计方法，基本控制结构，程序） 4.运行该程序，找出错误，直到结果正确（编辑源程序，编译，连接，调试）

例 已知1厘米等于0.3937英寸。编写一个程序，要求输入以厘米为单位的身高，然后显示该身高值等于多少英寸。 算法分析： 题目中已给出了数学上厘米和英寸换算的比率。因此程序只需从键盘获得以厘米为单位的身高，然后乘以这个比率，就可以得出以英寸为单位的身高。 基本步骤： 包含相应的头文件 根据题目需要定义变量（类型、名字、初值） 从键盘输入需要的数据 进行相关的运算 输出计算结果

例 包含头文件 #include <iostream> using namespace std; int main() { const double CM_INCH_RATIO=0.3973; double height_cm, height_in; cout<<"请输入你的身高(单位：厘米)："; cin>>height_cm; height_in = height_cm * CM_INCH_RATIO; cout<<"你的身高为"<<height_in<<"英寸"<<endl; return 0; } 定义变量 （类型、初值） 提示输入，然后得到输入的数据 进行 相关的 计算 输出需要 的结果