**这是本文档旧的修订版!**
第3章 C程序的基本结构、变量与数据类型
本章知识总结与上机教程。依据教材第3章整理,覆盖书页 P16~P32(即 PDF 物理第 38~54 页;全书前置 22 页无页码内容,故 书页 = PDF 页 − 22)。所有示例按 Linux + g++ 环境改写,尽量选取与教材相近的同类例子,建议边看边动手编译运行。
本章主线(教材 P16 教学目标):程序基本结构 → 变量(概念 / 数据类型 / 定义与赋值)→ 常量(4 种字面量)→ 运算符拓展(复合运算符、自增自减)→ 调试实训。
3.1 变量(教材 P18~P20)
3.1.1 变量的基本概念
程序运行过程中其值可以改变的量称为变量。使用一个变量,必须先在程序中定义它的名字和类型。
变量名的命名规则:
- 只能由字母、数字、下划线组成,第一个字符必须是字母或下划线;
- 区分大小写,
BeefPrice与beefprice是两个不同的变量; - 不能与 C/C++ 的关键字同名(如
int、float、return)。
命名建议:
- 名字要体现实际含义,提高程序可读性,如
beefPrice、total; - 避免在容易与数字
0混淆的地方使用大写字母O,同理小写字母l与数字1也要避免。
关键观念:变量不只是一个符号,它在内存中占有一个存储单元,变量名本质上是该存储单元的符号地址(&变量名 取到的就是它的地址)。定义一个变量,系统就按该类型为它分配相应大小的内存空间——这一点在以后学指针时极为关键。
3.1.2 变量的数据类型
变量取什么类型由任务需要(取值范围、精度)决定。C 语言的数据类型分两大类:
- 基本数据类型:整型、实型(浮点型)、字符型、无值型
void; - 构造数据类型:数组、指针、结构体、共用体、类等,由若干基本类型按特定规律组合而成。
同一种类型在不同编译器下占用的字节数可能不同(16 位编译器 int 为 16 位,32 位为 32 位),所以具体大小要以本机实测为准。
表 3.1 6 种整型数据类型(教材 P19)
| 数据类型 | 名称 | 占用字节数 | 取值范围 |
|---|---|---|---|
short(signed short) | 短整型(有符号短整型) | 2 | −32 768 ~ 32 767 |
unsigned short | 无符号短整型 | 2 | 0 ~ 65 535 |
int(signed int) | 整型(有符号整型) | 4 | −231 ~ 231−1 |
unsigned int | 无符号整型 | 4 | 0 ~ 232−1 |
long(signed long) | 长整型(有符号长整型) | 4 | −231 ~ 231−1 |
unsigned long | 无符号长整型 | 4 | 0 ~ 232−1 |
整型补充:在 C 语言中,有符号整数以二进制补码形式存储,最高位是符号位(0 表示正、1 表示负);无符号整数只能是正数。
表 3.2 3 种实型数据类型(教材 P19)
| 数据类型 | 名称 | 占用字节数 | 取值范围 |
|---|---|---|---|
float | 单精度型 | 4 | ±3.4×10−38 ~ 3.4×1038 |
double | 双精度型 | 8 | ±1.7×10−308 ~ 1.7×10308 |
long double | 长双精度型 | 10 | ±3.4×10−4932 ~ 1.1×104932 |
表 3.3 两种字符型数据类型(教材 P20)
| 数据类型 | 名称 | 占用字节数 | 取值范围 |
|---|---|---|---|
char(signed char) | 字符型(有符号字符型) | 1 | −128 ~ 127 |
unsigned char | 无符号字符型 | 1 | 0 ~ 255 |
用 signed(有符号)、unsigned(无符号)、long(长)、short(短)修饰 int 和 char 时,不写 signed 编译器默认为有符号。
上机验证(教材 P20 思考 3.1):C++ 提供了运算符 sizeof,用它查看各种类型占用的字节数。
#include <iostream> using namespace std; int main() { cout << "char 型占用字节数:" << sizeof(char) << endl; cout << "int 型占用字节数:" << sizeof(int) << endl; cout << "float 型占用字节数:" << sizeof(float) << endl; cout << "double 型占用字节数:" << sizeof(double) << endl; cout << "short int 型占用字节数:" << sizeof(short int) << endl; cout << "long int 型占用字节数:" << sizeof(long int) << endl; cout << "long double 型占用字节数:" << sizeof(long double) << endl; return 0; }
编译运行:
g++ sizeof_demo.cpp -o sizeof_demo ./sizeof_demo
典型输出(64 位 Linux 下 long 通常为 8 字节、long double 为 16 字节,与教材 VC 环境不同):
char 型占用字节数:1 int 型占用字节数:4 float 型占用字节数:4 double 型占用字节数:8 short int 型占用字节数:2 long int 型占用字节数:8 long double 型占用字节数:16
教材任务 3.1(教材 P16~P17)的同类例子:把“食堂电子计价”换成水果店计价,程序结构完全一致。
// ******************************************** // 程序名:3_1.cpp // 主要功能:计算应付货款 // 编译运行:g++ 3_1.cpp -o 3_1 && ./3_1 // ******************************************** #include <iostream> // 预编译命令 using namespace std; int main() // 主函数 { // 主函数开始 float beefPrice = 20.5; // 对象 1(牛肉单价,20.5 元/千克) float chickenPrice = 12.7; // 对象 2(鸡肉单价,12.7 元/千克) float beefWeight = 0.0; // 对象 3(牛肉重量,初始化为 0.0) float chickenWeight = 0.0; // 对象 4(鸡肉重量,初始化为 0.0) float total = 0.0; // 对象 5(总钱数,初始化为 0.0) cout << "请输入牛肉重量" << endl; // 提示信息 cin >> beefWeight; // 输入牛肉重量 cout << "请输入鸡肉重量" << endl; // 提示信息 cin >> chickenWeight; // 输入鸡肉重量 total = beefPrice * beefWeight + chickenPrice * chickenWeight; // 计算应付款 cout << "应付款" << total; // 输出应付款 return 0; } // 主函数结束
读懂这个程序,要抓住四部分(教材 P17):
- 程序说明部分:程序名、作者、编制时间、主要功能,用注释符号(两个连续斜杠)开头,注释内容不须机器编译;
- 主函数:以
main()为标识,是每一个程序都必须有的、执行一系列操作的入口;函数体由一对大括号{ }括起,包含声明部分和执行部分,按规定先声明、后执行;不声明,就不能执行; - 声明部分:第 11~15 行依次声明了 5 个对象。以
float beefPrice = 20.5;为例,float是该变量所取的数据类型,= 20.5是赋初值; - 执行部分:
cout输出提示信息;cin把键盘输入的实数分别赋给变量(原值 0.0 被新值覆盖);赋值语句完成计算;输出语句显示结果。
3.2 定义变量和赋初值(教材 P20~P22)
在主函数 main() 中,首先要对一些变量进行定义,包括为变量命名和指定数据类型以满足精度要求,使系统清楚为变量分配多少个内存单元有了依据。变量定义的一般格式为:
类型标识符(数据类型) 变量名1, 变量名2, ...;
例如定义变量名为 a 的整型变量,程序写成:
int a = 30;
系统会根据这个精度要求,安排 4 个字节的内存单元存放 a 的整数值。这里 a 是该内存单元的符号地址,&a 为变量地址。一讲到变量就要想到有一个地址与其关联(教材 P21 图 3.2),这在以后学指针时大有用处。
取地址示例:
#include <iostream> using namespace std; int main() { int a = 0; // 定义整型变量 a,初始化为 0 cout << "变量 a 的地址是:" << &a << endl; // 输出变量 a 的地址 cout << &a << " 中存的数是:" << a << endl; // 输出变量 a 的地址中所存的数 a = 97; // 给变量 a 赋一个新值 cout << "变量 a 的地址是:" << &a << endl; // 再输出变量 a 的地址 cout << &a << " 中存的数是:" << a << endl; // 再输出该地址中所存的数 return 0; }
运行要点:两次输出的地址不变,而地址中存的数由 0 变成 97——这正是“赋值是覆盖”的直接体现。
3.2.1 赋值符号与赋值表达式
在 C 中赋值符号为 =,赋值表达式的一般格式为:
<变量> = <表达式>
例如:
sum = 5050; // 将整数值 5050 赋给变量 sum avr = sum / 50; // 将 sum/50 赋给变量 avr
注意:= 是赋值,不是数学意义上的“相等”;判断相等要用 ==。
3.2.2 变量赋值的 5 个要素
给变量赋值时要注意以下 5 点(教材 P21~P22):
- 变量必须先定义后使用;
- 变量定义时就赋初值,是好的编程习惯,否则机器会给一个无意义的随机值;
- 变量的赋值过程是“覆盖“过程,即在变量地址单元中用新值替换旧值;
- 一个变量给另一个变量赋值后,该变量本身的值保持不变,相当于复制一份出来;
- 参与表达式运算的所有变量都保持原来的值不变。
下面举例说明(教材 P22):
int a = 0, b = 0, c = 0; // 定义 a、b、c 为整型变量,均初始化为 0 a = 27; // a 赋值为 27,覆盖了原来的 0 b = a; // b 赋值为 a,a 中的值复制给 b,但 a 中的值不变 c = a + b; // 将 a+b 的值赋给 c,a、b 仍保持 27 a = a + 1; // 将 a+1 的值赋给 a,a+1 的值为 28,覆盖原来的 27
执行过程(对应教材 P22 图 3.3):
| 语句 | a 的地址单元 | b 的地址单元 | c 的地址单元 |
|---|---|---|---|
| 定义并初始化 | 0 | 0 | 0 |
a = 27; | 27 | 0 | 0 |
b = a; | 27 | 27 | 0 |
c = a + b; | 27 | 27 | 54 |
a = a + 1; | 28 | 27 | 54 |
a = a + 1 可简化写作 a++,见 3.4.5 节。
3.3 常量(教材 P22~P23)
在程序中不能被改变的值称为常量。常量一般不是通过 int、char 之类的符号来指明类型,而是通过值的书写格式来表明它的类型。根据基本数据类型,常量可分为整型、实型、字符、字符串 4 种。
3.3.1 整型常量
整型常量根据需要分别用十进制、十六进制等形式书写:
- 十进制:由数字 0~9 和正、负号组成,例如
12、-36; - 十六进制:由数字 0~9、字母 a~f 和 A~F 组成,前面加上
0x或0X,例如0x7f32、0xfefe。
3.3.2 实型常量
- 十进制小数形式:由数字和小数点组成(必须有小数点),例如
0.321、321.0、3.1416、0.0; - 指数形式:如
13e3或13E3都表示 13×103。
注意(教材 P23):
- 字母
e(或E)之前必须是数字,其后的指数必须是整数。例如e3、1e3.5、.e3、e都不是合法的指数形式;而-1.56E+12、2.87e-3是有效的浮点常量。 - 可以省略正号;可以没有小数点(
2E5)或指数部分(19.28),但二者不能同时省略;可以省略纯小数部分(3.E16)或整数部分(.45E-6)。浮点常量中不要使用空格,1.56 E+12是错误的。 - 一个实数可以有多种指数表示方式,例如
1234.56可表示为1234.56e0、123.456e1、12.3456e2、1.23456e3,其中1.23456e3为规范化的指数形式。实数用指数形式输出时,按规范化形式输出。
3.3.3 字符常量
用一对单引号括起来的一个字符称为字符常量,例如 'b'、'8'。注意:单引号中的字符不能是单引号(要输出单引号必须用转义字符 \' ,见 3.4.1 节)。
3.3.4 字符串常量
用一对双引号括起来的一个字符序列称为字符串常量,字符序列由若干个字符组成。
表 3.4 字符常量与字符串常量的区别(教材 P23)
| 比较项 | 字符常量 | 字符串常量 |
|---|---|---|
| 内容 | 单个字符 | 多个字符 |
| 分界符 | 单引号 | 双引号 |
| 结束标识 | 无 | 以字符 \0 为结束标识 |
例如 'abc' 和 "abc" 不同:前者是字符常量,后者是字符串常量;两者在内存中的存储方式也不同,前者只占用 3 个字节(abc),后者要占用 4 个字节(abc 和 \0)。
Linux 提示:g++ 对 'abc' 这类多字符常量会给出警告(multi-character character constant),其取值由实现定义,实际编程中不要这样写。
3.4 知识拓展(教材 P23~P29)
3.4.1 转义字符
字符常量需要用单引号作分界符,而单引号中的字符不能是单引号,此时必须用转义字符表示。表 3.5 列出了 7 个以反斜杠开头的转义字符。
表 3.5 常用的转义字符(教材 P24)
| 转义字符 | ASCII 码 | 含义 | 转义字符 | ASCII 码 | 含义 |
|---|---|---|---|---|---|
| \a | 7 | 响铃 | \" | 34 | 双引号 |
| \t | 9 | 制表符 | \\ | 92 | 反斜杠 |
| \n | 10 | 换行 | \' | 39 | 单引号 |
| \r | 13 | 回车 |
上机(教材 P24 思考 3.2):运行下面的程序,观察 \a、\n、\t、\" 的作用。
#include <iostream> using namespace std; int main() { cout << "Hello!" << '\a' << endl; // 响铃 cout << "\tHello!" << "Hello!" << endl; // 制表符 cout << "\tHello!\n" << "Hello!" << endl; // 换行符 cout << "I say \"Hello!\"" << endl; // 用转义字符表示双引号 return 0; }
运行结果:
Hello!
Hello!Hello!
Hello!
Hello!
I say "Hello!"
说明:第 2、3 行开头空出一段是制表符 \t 的作用,第 3、4 行之间另起一行是换行符 \n 的作用。其中 endl 是 C++ 提供的专门操作符,表示”end line”,功能与换行符相同。
Linux 提示:很多终端的提示音被关闭,\a 可能听不到声音,可改用 printf("\a"); fflush(stdout); 或打开终端提示音再试。
3.4.2 标识符常量
在 C 中不仅有变量名,还有符号常量名、函数名、类型名、文件名等有效字符序列,它们统称标识符,命名方法相同(区分大小写、首字符为字母或下划线、不得与关键字相同)。C 中提供两种方法定义标识符常量(符号常量,教材 P24~P25):
#define PRICE 46 // 一种是采用编译预处理命令 #define PI 3.1415926 const float pi = 3.1415926; // 另一种是使用常量说明符 const
其中 PRICE、PI 是用编译预处理命令定义的,pi 是用常量说明符 const 定义的。
3.4.3 字符数据的输入
实际应用中经常只需要输入单个字符。用 cin 输入数据时,操作者必须在输入字符后还要按 Enter 键(回车键)表示输入结束。为了尽可能简化操作,教材使用 conio.h 中的两个函数(教材 P25):
getche():通过键盘输入一个字符,并在屏幕上显示(通常称为“回显”);getch():通过键盘输入一个字符,不在屏幕上显示。
Linux 环境提示:conio.h 是 TC/Windows 专有的头文件,Linux 的 g++ 中不存在。要在 Linux 上实现“读一个字符且不回显”,可用 termios 关闭行缓冲与回显,或使用 ncurses 库的 getch()。等价实现如下:
#include <iostream> #include <termios.h> #include <unistd.h> using namespace std; // 关闭终端的行缓冲与回显,读一个字符后恢复——相当于教材中的 getch() char getch() { termios oldt, newt; tcgetattr(STDIN_FILENO, &oldt); newt = oldt; newt.c_lflag &= ~(ICANON | ECHO); // 关闭行缓冲与回显 tcsetattr(STDIN_FILENO, TCSANOW, &newt); char c = getchar(); tcsetattr(STDIN_FILENO, TCSANOW, &oldt); return c; } int main() { cout << "请输入 4 位密码:"; cout.flush(); // 强制输出缓冲区内容,使提示立即显示 for (int i = 0; i < 4; i++) { getch(); // 从键盘输入一个字符,但不显示 cout << "*" << flush; // 再显示一个 * } cout << endl; return 0; }
显示效果(对应教材 P26 思考 3.4):
请输入 4 位密码:****
为什么必须 flush:为了提高程序执行效率,C++ 把要输出的数据先保存在一个缓冲区中,不向屏幕输出,直到出现 endl 或 \n 后才一起显示到屏幕上。若不加 « flush,“请输入 4 位密码:”要等到执行后面一句 cout 时才显示,而用户所按的字符会显示到前面,不符合题意。flush 的作用是强制输出缓冲区中的内容,然后把缓冲区清除。
字符与 ASCII 码(教材 P25 思考 3.3 的 Linux 版):字符以 ASCII 码的形式存储在计算机中,用强制整型转换 (int) 可把字符型值转换为整型值,(int)c 即字符 c 的 ASCII 码。
#include <iostream> using namespace std; int main() { char c; cout << "字符\"" << flush; // 先输出前半句,flush 保证立即显示 cin >> c; cout << "\" 的 ASCII 码是 " << (int)c << endl; return 0; }
按 D 键时输出:字符“D” 的 ASCII 码是 68。
3.4.4 复合运算符
复合运算符是由赋值运算符与其他运算符组合而成的。采用复合运算符可以使程序精炼、提高编译效率。复合运算符有 5 个:+=、-=、*=、/=、%=。
运算时,复合运算符左边是变量,右边是表达式,例如 a += 3 等价于 a = a + 3,即先使 a 加 3 再赋给 a。
表 3.6 复合运算符(教材 P26)
| 用复合运算符 | 等效表达式 | 举例说明 | a 初值为 3 时的计算结果 |
|---|---|---|---|
a += 3 | 变量 = 变量 + 表达式 | a = a + 3 | a = 6 |
a -= 3 | 变量 = 变量 − 表达式 | a = a - 3 | a = 0 |
a *= 3 | 变量 = 变量 × 表达式 | a = a * 3 | a = 9 |
a /= 3 | 变量 = 变量 ÷ 表达式 | a = a / 3 | a = 1 |
a %= 3 | 变量 = 变量 ÷ 表达式的余数 | a = a % 3 | a = 0 |
上机(教材 P27 思考 3.5、3.6):
#include <iostream> using namespace std; int main() { int a = 9, b = 3; a /= 3; // 等价于 a = a / 3,a 变为 3 b *= 2; // 等价于 b = b * 2,b 变为 6 cout << "a=" << a << ", b=" << b << endl; int x = 2, y = 3; x *= (y + 8); // 等价于 x = x * (y + 8) = 22 cout << "x=" << x << endl; return 0; }
输出:
a=3, b=6 x=22
3.4.5 自增自减运算
加 1 运算符 ++ 和减 1 运算符 -- 是单目运算符,它们可以出现在变量(运算对象)的左侧或右侧,以前缀运算符或后缀运算符使用,但运算量必须是变量。例如 a++、++a、a--、--a 都是合法的表示形式,而 (a+b)++、2-- 都是不合法的。
++ 和 -- 作为前缀或后缀使用时,对变量而言运算结果都一样;但对表达式而言,结果确实不一样。
作为前缀:
int n = 5; m = ++n; // 首先将变量 n 的值加 1,即 n 为 6,然后将 n 赋给 m,m 的值为 6
作为后缀:
int n = 5; m = n++; // 首先将变量 n 的值赋给 m,即 m 为 5,然后将 n 加 1,n 的值为 6
表 3.7 4 种情况(n 初值为 5,教材 P28)
| 语句 | 等价的语句 | 执行后 m 的值 | 执行后 n 的值 |
|---|---|---|---|
m = ++n; | n = n + 1; m = n; | 6 | 6 |
| m = --n; | n = n - 1; m = n; | 4 | 4 |
m = n++; | m = n; n = n + 1; | 5 | 6 |
| m = n--; | m = n; n = n - 1; | 5 | 4 |
上机(教材 P28 思考 3.7、3.8):
#include <iostream> using namespace std; int main() { int a = 6, b = 3, x, y; x = ++a; // a 先变 7,再赋给 x,x = 7 y = b++; // 先把 b 赋给 y,y = 3,b 再变 4 cout << "x: " << x << endl; cout << "y: " << y << endl; a = 6; b = 3; x = (--a) + 2; // a 先变 5,x = 5 + 2 = 7 y = (b--) + 3; // y = 3 + 3 = 6,b 再变 2 cout << "x: " << x << endl; cout << "y: " << y << endl; return 0; }
输出:
x: 7 y: 3 x: 7 y: 6
结合性(教材 P29 思考 3.9):++/– 的优先级高于一元负号 -,并且它们只能作用于变量。
int a = 6, x, y, z; x = -a++; // 等价于 x = -(a++),x = -6,a 变为 7 y = -(a++); // 与上一句同义 z = (-a)++; // 不合法:(-a) 不是变量,g++ 报错 lvalue required as increment operand
3.5 思考与实训:给一段错误程序"找病"(教材 P29~P32)
教材给出下面 9 行有错的程序(原文如下,保持原样,对应教材第 4~9 行):
#include <iostream> using namespace std; int main() { int x1, x2 // 第 5 行:缺分号 x1 = 5 // 第 6 行:缺分号 x2 = 10 // 第 7 行:缺分号 y = x1 * x2 // 第 8 行:y 未定义,且缺分号 cout << "y=" << x << endl // 第 9 行:x 未定义(变量名写错),且缺分号 }
在 Linux 下编译:
g++ cpp1.cpp -o cpp1
g++ 会输出一串报错信息(与教材 VC++ 6.0 的错误代号不同,含义相当):
cpp1.cpp:5:14: error: expected ';' before 'x1' cpp1.cpp:6:11: error: expected ';' before 'x1' cpp1.cpp:7:12: error: expected ';' before 'x2' cpp1.cpp:8:5: error: 'y' was not declared in this scope cpp1.cpp:9:13: error: 'x' was not declared in this scope cpp1.cpp:10:1: error: expected '}' at end of input
逐条分析(教材 P30):
- 前 3 条报错都属“缺少分号“,在相应行的行末补上
;即可; y was not declared:第 8 行出现y,但第 5 行只定义了x1、x2,y确实没有定义,应在int x1, x2;中补上y;x was not declared:这里不能盲目按提示也把x定义出来——仔细读懂题意就知道本题要输出的是y值,而程序中输出的是x,因此应把cout中的x改成y,x在此处多余;expected '}' at end of input:文件没有结束,说明少了一个右大括号},补上即可。
结论:不要盲目根据提示改程序,而要在读懂题意的基础上以提示作为帮助来修改程序。
修改后的正确程序(教材 P31):
#include <iostream> using namespace std; int main() { int x1, x2, y; x1 = 5; x2 = 10; y = x1 * x2; cout << "y=" << y << endl; return 0; }
编译运行 ./cpp1,输出 y=50,0 error。(教材在 VC 下还会出现一条”函数没有返回值”的警告,对应 main 缺 return 语句;加上 return 0; 即可。C 语言中警告一般不影响运行,但从严谨的角度应尽量修改。)
调试总结(教材 P31):
- 每个语句都要加分号;
- 初始化所有用到的值;
- 关键字或变量不要“缺斤少两”;
- 使用
cout «、cin »等输入/输出流时,程序开始必须加上#include <iostream>; main()函数默认返回值为整型,必须在函数名前加上int,且不要忘记在程序结束前添加return 0;。
查错顺序(对应教材 P31 图 3.6 程序框图):
- 先查 ① ② ④:
#include与using namespace(①)、int main()(②)、return 0;与最后的}(④)——这些是标准化的,检查起来很容易,只要认真就行; - 再查 ③,即主函数中的主体:前面是定义一些变量,后面是执行一些语句。掌握以下原则:
- 原则 1:每个变量都要先定义才能使用;
- 原则 2:每一行语句的最后都要有一个分号
;。
- 查 ③ 时,先看是否每一行都有分号结束该行,再看有没有变量在该行之前没定义过,最后再看有没有语句的格式问题或构思上的逻辑错误(教材 P32)。
- 教材建议:上机之前先把程序认真书写在纸上,反复检查,觉得无误了再输入到机器里——这个过程也是动手动脑的过程。
3.6 小结(教材 P32)
- 掌握变量的概念和变量赋值的 5 个要素,对于程序设计是十分重要的;
- 引入变量后,用计算机求解问题就有了初步的基础。
3.7 知识巩固(教材 P32)
【试题 1】以下选项中合法的实型常数是__。
A. 5E2.0 B. E−3 C. .2E0 D. 1.3E
【试题 2】仔细阅读下列程序,写出运行之后的输出结果。
#include <iostream> using namespace std; int main() { char m; m = 'B' + 32; cout << "m=" << m << endl; return 0; }
【试题 3】在下列 4 个选项中,回答 C++ 语言中运算对象必须是整型的运算符是__。
A. %= B. / C. = D. <=
【试题 4】以下合法的赋值语句是__。
A. x = y = 100 B. d-- C. x + y D. c = int(a + b);
附:本次整理覆盖教材第3章书页 P16~P32(PDF 物理页 38~54,全书前置 22 页无页码内容)。示例均按 64 位 Linux + g++ 环境改写,输出中的字节数、地址值会因机器与编译器而异。
# 第3章 C程序的基本结构、变量与数据类型 ## 3.1 变量(P18~P20) ### 变量的基本概念 - 程序运行中值可以改变的量 - 命名:首字符为字母或下划线 - 区分大小写,不得与关键字同名 - 变量名 = 存储单元的符号地址 ### 变量的数据类型 - 基本类型:整型 / 实型 / 字符型 / void - 构造类型:数组、指针、结构体、共用体、类 - sizeof 实测本机字节数 ## 3.2 定义变量和赋初值(P20~P22) ### 定义格式与地址 - 类型标识符 变量名1, 变量名2; - &变量名 取地址,变量有内存单元 ### 赋值符号与表达式 - <变量> = <表达式> - = 是赋值,== 才是判断相等 ### 变量赋值的 5 个要素 - 先定义后使用 - 定义时赋初值 - 赋值是"覆盖" - 变量间赋值是复制,原值不变 - 参与运算的变量值不变 ## 3.3 常量(P22~P23) ### 整型常量 - 十进制、十六进制(0x) ### 实型常量 - 小数形式、指数形式 - e 前必须是数字,指数必须是整数 - 规范化指数形式 1.23456e3 ### 字符与字符串常量 - 单引号 vs 双引号 - 字符串以 \0 结束,占 4 字节 ## 3.4 知识拓展(P23~P29) ### 转义字符(表 3.5) - \a 响铃、\t 制表符、\n 换行 - \r 回车、\\" \\\\ \\' 三个符号 ### 标识符常量 - #define 预处理命令 - const 常量说明符 ### 字符数据的输入 - getche() 回显 / getch() 不回显 - Linux 用 termios 替代 conio.h - flush 强制刷新输出缓冲区 - (int)c 取字符的 ASCII 码 ### 复合运算符(表 3.6) - += -= *= /= %= ### 自增自减运算(表 3.7) - 前置 ++n:先加 1 再赋值 - 后缀 n++:先赋值再加 1 - 只能作用于变量 ## 3.5 思考与实训:调试找错(P29~P32) ### 9 行有错程序 - 缺分号 → 补 ; - y 未定义 → 定义 y - x 未定义 → 读懂题意改成 y - 少 } → 补右大括号 ### 查错顺序 - 先查头文件 / main / return 0 与 } - 再查主函数主体①②④ - 原则1:先定义后使用 - 原则2:每行语句末尾有分号 ## 3.6 小结与 3.7 知识巩固(P32) - 变量概念 + 赋值 5 要素 - 试题 1~4 练习