程序设计基础:第3章

第3章 C程序的基本结构、变量与数据类型

本章知识总结与上机教程。依据教材第3章整理,覆盖书页 P16~P32(即 PDF 物理第 38~54 页;全书前置 22 页无页码内容,故 书页 = PDF 页 − 22)。所有示例按 Linux + g++ 环境改写,尽量选取与教材相近的同类例子,建议边看边动手编译运行。

本章主线(教材 P16 教学目标):程序基本结构 → 变量(概念 / 数据类型 / 定义与赋值)→ 常量(4 种字面量)→ 运算符拓展(复合运算符、自增自减)→ 调试实训。


程序运行过程中其值可以改变的量称为变量。使用一个变量,必须先在程序中定义它的名字和类型。

变量名的命名规则:

  • 只能由字母、数字、下划线组成,第一个字符必须是字母或下划线;
  • 区分大小写,BeefPrice 与 beefprice 是两个不同的变量;
  • 不能与 C/C++ 的关键字同名(如 int、float、return)。

命名建议:

  • 名字要体现实际含义,提高程序可读性,如 beefPrice、total;
  • 避免在容易与数字 0 混淆的地方使用大写字母 O,同理小写字母 l 与数字 1 也要避免。

关键观念:变量不只是一个符号,它在内存中占有一个存储单元,变量名本质上是该存储单元的符号地址(&变量名 取到的就是它的地址)。定义一个变量,系统就按该类型为它分配相应大小的内存空间——这一点在以后学指针时极为关键。

变量取什么类型由任务需要(取值范围、精度)决定。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 被新值覆盖);赋值语句完成计算;输出语句显示结果。

在主函数 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——这正是“赋值是覆盖”的直接体现。

在 C 中赋值符号为 =,赋值表达式的一般格式为:

<变量> = <表达式>

例如:

sum = 5050;        // 将整数值 5050 赋给变量 sum
avr = sum / 50;    // 将 sum/50 赋给变量 avr

注意:= 是赋值,不是数学意义上的“相等”;判断相等要用 ==。

给变量赋值时要注意以下 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 节。


在程序中不能被改变的值称为常量。常量一般不是通过 int、char 之类的符号来指明类型,而是通过值的书写格式来表明它的类型。根据基本数据类型,常量可分为整型、实型、字符、字符串 4 种。

整型常量根据需要分别用十进制、十六进制等形式书写:

  • 十进制:由数字 0~9 和正、负号组成,例如 12、-36;
  • 十六进制:由数字 0~9、字母 a~f 和 A~F 组成,前面加上 0x 或 0X,例如 0x7f32、0xfefe。
  • 十进制小数形式:由数字和小数点组成(必须有小数点),例如 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 为规范化的指数形式。实数用指数形式输出时,按规范化形式输出。

用一对单引号括起来的一个字符称为字符常量,例如 'b'、'8'。注意:单引号中的字符不能是单引号(要输出单引号必须用转义字符 \' ,见 3.4.1 节)。

用一对双引号括起来的一个字符序列称为字符串常量,字符序列由若干个字符组成。

表 3.4 字符常量与字符串常量的区别(教材 P23)

比较项 字符常量 字符串常量
内容 单个字符 多个字符
分界符 单引号 双引号
结束标识 无 以字符 \0 为结束标识

例如 'abc' 和 "abc" 不同:前者是字符常量,后者是字符串常量;两者在内存中的存储方式也不同,前者只占用 3 个字节(abc),后者要占用 4 个字节(abc 和 \0)。

Linux 提示:g++ 对 'abc' 这类多字符常量会给出警告(multi-character character constant),其取值由实现定义,实际编程中不要这样写。


字符常量需要用单引号作分界符,而单引号中的字符不能是单引号,此时必须用转义字符表示。表 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); 或打开终端提示音再试。

在 C 中不仅有变量名,还有符号常量名、函数名、类型名、文件名等有效字符序列,它们统称标识符,命名方法相同(区分大小写、首字符为字母或下划线、不得与关键字相同)。C 中提供两种方法定义标识符常量(符号常量,教材 P24~P25):

#define PRICE 46              // 一种是采用编译预处理命令
#define PI 3.1415926
const float pi = 3.1415926;   // 另一种是使用常量说明符 const

其中 PRICE、PI 是用编译预处理命令定义的,pi 是用常量说明符 const 定义的。

实际应用中经常只需要输入单个字符。用 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。

复合运算符是由赋值运算符与其他运算符组合而成的。采用复合运算符可以使程序精炼、提高编译效率。复合运算符有 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

加 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

教材给出下面 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)。
  • 教材建议:上机之前先把程序认真书写在纸上,反复检查,觉得无误了再输入到机器里——这个过程也是动手动脑的过程。

  • 掌握变量的概念和变量赋值的 5 个要素,对于程序设计是十分重要的;
  • 引入变量后,用计算机求解问题就有了初步的基础。

【试题 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 练习

该主题尚不存在

您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。

  • 程序设计基础/第3章.1791380906.txt.gz
  • 最后更改: 2026/10/07 21:48
  • 由 张叶安