====== 第3章 C程序的基本结构、变量与数据类型 ======
===== 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
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 // 预编译命令
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
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''——这正是"赋值是覆盖"的直接体现。
> 提问:指针存的的是地址,那么指针是默认产生的吗,听说过有指针的指针,这样的话会不会产生,指针的指针的指针的指针的指针的指针啊
**答(预告,详见第 4 章)**:指针**不会默认产生**,必须自己定义(如 %%int *p = &a;%%)。变量本身在内存中都有地址,但 ''&a'' 只取到一个地址**值**,并不等于系统替你造了个指针。指针的指针同理——**不会自动套娃**:想多一层,就得自己多定义一个变量。
int a = 42;
int *p = &a; // 一级:存 a 的地址
int **pp = &p; // 二级:存 p 的地址
int ***ppp = &pp; // 三级
每层指针本身仍只占 8 字节,多一层只是多解引用一次。实际代码通常用到二级(如 %%char **argv%%)为止,再往上可读性极差,无实际必要。
202610142236
==== 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
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
#include
#include
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
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
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
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
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
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 '';
- ''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
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++ 环境改写,输出中的字节数、地址值会因机器与编译器而异。//
```mdk height=520 color=#4f46e5
# 第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 练习
```