程序设计基础:第3章

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

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

变量名的命名规则:

  • 只能由字母、数字、下划线组成,第一个字符必须是字母或下划线;
  • 区分大小写,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——这正是“赋值是覆盖”的直接体现。

提问:指针存的的是地址,那么指针是默认产生的吗,听说过有指针的指针,这样的话会不会产生,指针的指针的指针的指针的指针的指针啊

答(预告,详见第 4 章):指针不会默认产生,必须自己定义(如 int *p = &a;)。变量本身在内存中都有地址,但 &a 只取到一个地址值,并不等于系统替你造了个指针。指针的指针同理——不会自动套娃:想多一层,就得自己多定义一个变量。

int    a   = 42;
int   *p   = &a;     // 一级:存 a 的地址
int  **pp  = &p;     // 二级:存 p 的地址
int ***ppp = &pp;    // 三级

每层指针本身仍只占 8 字节,多一层只是多解引用一次。实际代码通常用到二级(如 char argv)为止,再往上可读性极差,无实际必要。 ==== 3.2.1 赋值符号与赋值表达式 ==== 在 C 中赋值符号为 =,赋值表达式的一般格式为: <code> <变量> = <表达式> </code> 例如: <code cpp> sum = 5050; 将整数值 5050 赋给变量 sum avr = sum / 50; 将 sum/50 赋给变量 avr </code> 注意:= 是赋值,不是数学意义上的“相等”;判断相等要用 ==。 ==== 3.2.2 变量赋值的 5 个要素 ==== 给变量赋值时要注意以下 5 点(教材 P21~P22): - 变量必须先定义后使用; - 变量定义时就赋初值,是好的编程习惯,否则机器会给一个无意义的随机值; - 变量的赋值过程是“覆盖“过程,即在变量地址单元中用新值替换旧值; - 一个变量给另一个变量赋值后,该变量本身的值保持不变,相当于复制一份出来; - 参与表达式运算的所有变量都保持原来的值不变。 下面举例说明(教材 P22): <code cpp> 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 </code> 执行过程(对应教材 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、\" 的作用。 <code cpp> #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; } </code> 运行结果: <code> Hello! Hello!Hello! Hello! Hello! I say “Hello!” </code> 说明:第 2、3 行开头空出一段是制表符 \t 的作用,第 3、4 行之间另起一行是换行符 \n 的作用。其中 endl 是 C++ 提供的专门操作符,表示“end line”,功能与换行符相同。 Linux 提示:很多终端的提示音被关闭,\a 可能听不到声音,可改用 printf("\a"); fflush(stdout); 或打开终端提示音再试。 ==== 3.4.2 标识符常量 ==== 在 C 中不仅有变量名,还有符号常量名、函数名、类型名、文件名等有效字符序列,它们统称标识符,命名方法相同(区分大小写、首字符为字母或下划线、不得与关键字相同)。C 中提供两种方法定义标识符常量(符号常量,教材 P24~P25): <code cpp> #define PRICE 46 一种是采用编译预处理命令 #define PI 3.1415926 const float pi = 3.1415926; 另一种是使用常量说明符 const </code> 其中 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()。等价实现如下: <code cpp> #include <iostream> #include <termios.h> #include <unistd.h> using namespace std; 关闭终端的行缓冲与回显,读一个字符后恢复——相当于教材中的 getch() char getch() { termios oldt, newt; tcgetattr(STDINFILENO, &oldt); newt = oldt; newt.clflag &= ~(ICANON | ECHO); 关闭行缓冲与回显 tcsetattr(STDINFILENO, TCSANOW, &newt); char c = getchar(); tcsetattr(STDINFILENO, TCSANOW, &oldt); return c; } int main() { cout « “请输入 4 位密码:”; cout.flush(); 强制输出缓冲区内容,使提示立即显示 for (int i = 0; i < 4; i++) { getch(); 从键盘输入一个字符,但不显示 cout « “*” « flush; 再显示一个 * } cout « endl; return 0; } </code> 显示效果(对应教材 P26 思考 3.4): <code> 请输入 4 位密码: </code> 为什么必须 flush:为了提高程序执行效率,C++ 把要输出的数据先保存在一个缓冲区中,不向屏幕输出,直到出现 endl 或 \n 后才一起显示到屏幕上。若不加 « flush,“请输入 4 位密码:”要等到执行后面一句 cout 时才显示,而用户所按的字符会显示到前面,不符合题意。flush 的作用是强制输出缓冲区中的内容,然后把缓冲区清除。 字符与 ASCII 码(教材 P25 思考 3.3 的 Linux 版):字符以 ASCII 码的形式存储在计算机中,用强制整型转换 (int) 可把字符型值转换为整型值,(int)c 即字符 c 的 ASCII 码。 <code cpp> #include <iostream> using namespace std; int main() { char c; cout « “字符\”“ « flush; 先输出前半句,flush 保证立即显示 cin » c; cout « “\” 的 ASCII 码是 ” « (int)c « endl; return 0; } </code> 按 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): <code cpp> #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; } </code> 输出: <code> a=3, b=6 x=22 </code> ==== 3.4.5 自增自减运算 ==== 加 1 运算符 ++ 和减 1 运算符 -- 是单目运算符,它们可以出现在变量(运算对象)的左侧或右侧,以前缀运算符或后缀运算符使用,但运算量必须是变量。例如 a++、++a、a--、--a 都是合法的表示形式,而 (a+b)++、2-- 都是不合法的。 ++ 和 -- 作为前缀或后缀使用时,对变量而言运算结果都一样;但对表达式而言,结果确实不一样。 作为前缀: <code cpp> int n = 5; m = ++n; 首先将变量 n 的值加 1,即 n 为 6,然后将 n 赋给 m,m 的值为 6 </code> 作为后缀: <code cpp> int n = 5; m = n++; 首先将变量 n 的值赋给 m,即 m 为 5,然后将 n 加 1,n 的值为 6 </code> 表 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): <code cpp> #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; } </code> 输出: <code> x: 7 y: 3 x: 7 y: 6 </code> 结合性(教材 P29 思考 3.9):++/-- 的优先级高于一元负号 -,并且它们只能作用于变量。 <code cpp> 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 </code> —- ===== 3.5 思考与实训:给一段错误程序“找病”(教材 P29~P32) ===== 教材给出下面 9 行有错的程序(原文如下,保持原样,对应教材第 4~9 行): <code cpp> #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 未定义(变量名写错),且缺分号 } </code> 在 Linux 下编译: <code bash> g++ cpp1.cpp -o cpp1 </code> g++ 会输出一串报错信息(与教材 VC++ 6.0 的错误代号不同,含义相当): <code> 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 </code> 逐条分析(教材 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): <code cpp> #include <iostream> using namespace std; int main() { int x1, x2, y; x1 = 5; x2 = 10; y = x1 * x2; cout « “y=” « y « endl; return 0; } </code> 编译运行 ./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】仔细阅读下列程序,写出运行之后的输出结果。 <code cpp> #include <iostream> using namespace std; int main() { char m; m = 'B' + 32; cout « “m=” « m « endl; return 0; } </code> 【试题 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 练习

该主题尚不存在

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

  • 程序设计基础/第3章.1791988267.txt.gz
  • 最后更改: 2026/10/14 22:31
  • 由 张叶安