系统软件#

• 操作系统
  • 优秀的商业公司、开源组织，站出来，编写一套针对硬件的底层程序。管理声卡、显卡、网卡、磁盘等这些硬件。
  • 概念：操作系统就是管理计算机硬件与软件资源的一个计算机程序。本质：程序！！

flowchart TB
    A["播放 MP3"] -->|向下| OS["操作系统"]
    B["网络聊天"] -->|向下| OS
    C["查看"] -->|向下| OS
    OS -->|向下| SK["声卡"]
    OS -->|向下| XK["显卡"]
    OS -->|向下| WK["网卡"]
    OS -->|向下| CP["磁盘"]
    OS -.->|向上：图形界面| D["图形界面：普通用户，鼠标点点点"]
    OS -.->|向上：终端界面| E["终端界面：普通用户、开发人员都可以使用"]
    OS -.->|向上：系统调用| F["系统调用：操作系统提供给开发人员使用的函数"]

• 操作系统（OS）向下的作用：提供驱动程序，管理硬件
• 操作系统（OS）向上的作用：
  • 图形界面：普通用户，鼠标点点点
  • 终端界面：普通用户、开发人员都可以使用
  • 系统调用：操作系统提供给开发人员使用的函数

• 语言系统
  • 计算机语言：C、C++、Java、Python、PHP …
  • 机器语言：二进制（10101001）

应用软件#

需要根据实际需求，来制定功能。

• 文件处理
• 图形处理
• 表格处理
• 实时控制

计算机语言发展史#

1. 机器语言：101100110
2. 汇编语言：助记符：abc ← 10100101。问题：硬件不同，指令不同。不同架构（CPU）指令集不同。只能支持某一种特定的硬件，跨平台性差。衍生出 B 语言。
3. C 语言：借助编译器，就能将 C 代码，转换成各种平台使用的指令。跨平台。
4. C++、Java、Oc、Python：面向对象编程。程序扩展性好！
5. SQL 语句：人类易理解。

机器生汇编，汇编生 B，B 生 C，C 生万物！！！

C 语言标准#

标准简史：

1. 1972 年 C 语言在贝尔实验室诞生，丹尼斯·里奇参考 B 语言开发
2. 1970-80 年代，C 语言被广泛应用，产生很多不同的 C 语言版本，程序可移植性比较差
3. 1983 年，美国国家标准委员会（ANSI）成立了一个小组来制定 C 语言的标准：C 语言支持哪些语法、支持哪些功能等
4. 1989 年，通过了 C 语言的第一个标准，C89 标准
5. 1990 年，国际标准化组织（ISO）和国际电工委员会（IEC）将 C89 标准当做国际的 C 语言标准。C90 标准、C89 和 C90 指的是同一个标准
6. 1994 年 ISO 和 IEC 对 C89 标准进行修订，C94 标准，由于并没有增加新的语法特性，还是叫做 C89 或者 C90
7. 1995 年 ISO 和 IEC 再次做了修正，C95 标准
8. 1999 年 ISO 和 IEC 发布了 C 语言新标准，C 语言第二个标准。在该标准中，新增许多实用的 C 语言语法特性，增加新的关键字、可变长数组等等。C99 标准
9. 2007 年，重新修订了 C 语言
10. 2011 年，发布新的版本。新增了一些语法，泛型、国际化支持。目前为止最新版本是 C11

标准的影响：

1. 可将 C 语言的标准理解为 C 语言说明书。但，其并没有强制性约束力。

   如：微软拿到标准，认为有些标准不合理，不支持。微软认为某些特性非常好，但标准中没有，微软自己新增语法。

2. 如果编译器不支持标准，我们即使使用标准中的语法仍然会报错。
3. 编译器版本也会影响程序。因此，编写程序之前要确定编译器版本。

常见的 C/C++ 编译器：

C 语言的优缺点#

优点：

• 学习成本低
• 运行速度快
• 功能强大

缺点：

• 代码实现周期长
• 可移植性差
• 对经验要求高
• 对平台库依赖多

C 语言的应用领域#

1. 服务器
2. 操作系统
3. 上层应用。MFC、QT
4. 嵌入式
5. 人工智能、硬件驱动
6. 中间件
7. 网络攻防、数据安全
8. 大学必修课
9. 名企、外企

修改计算机显示扩展名#

打开任意一个目录 → 查看 → 文件扩展名（勾选）

编写第一个 hello world 程序#

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    printf("hello world\n");
6
    return 0;
7
}

编译 hello world 程序 —— 得到机器能识别的二进制码#

1
# 编译 C 程序，得到二进制码
2
gcc HelloWorld.c -o HelloWorld.exe
3

4
# 运行二进制程序
5
HelloWorld.exe

快捷打开 HelloWorld.c 文件所在目录#

1. 进入 HelloWorld.c 文件所在目录
2. 直接在「地址栏」中键入 cmd，不需要 cd 目录。切换。

代码释义#

printf 详解：

• printf()：C 语言向屏幕输出字符使用的函数
• “helloworld”：待写出的字符串内容
• \n：回车换行

return 详解：

• return：返回。C 程序要求，main 函数要有返回值。借助 return 实现返回
• 0：成功！因为 int，返回整数

注意事项#

1. 程序中使用的所有的字符，全部是「英文半角」字符。
2. 程序中，严格区分大小写。
3. ; 代表一行结束。不能使用中文「；」，必须是英文。

main 函数标准类型#

• 无参：

  1
  int main(void) { return 0; }

• 有参：

  1
  int main(int argc, char *argv[]) { return 0; }

main 函数其他类型#

都能正常运行，但不是 main 的标准语法格式。

1
// 都能正常运行，但不是 main 的标准语法格式。
2
void main(int argc, char *argv[]);
3
void main(void);
4
int main();
5
int main(void);
6
main();
7
main(int argc, char *argv[]);

整体过程#

flowchart LR
    SRC["源文件 hello.c"] -.->|gcc hello.c -o hello.exe| EXE["可执行文件 hello.exe"]
    SRC -.->|-E| PRE["预处理"]
    PRE -->|hello.i 预处理文件| COM["编译"]
    COM -->|hello.s 汇编文件| ASM["汇编"]
    ASM -->|hello.o 目标文件 （本质：二进制）| LINK["链接"]
    LINK --> EXE

预处理#

• 参数：-E
• 生成的文件：xxx.i 预处理文件
• 使用命令：gcc -E xxx.c -o xxx.i
• 工具：预处理器（包含在 gcc 编译集合工具中）

完成的工作：

1. 头文件展开

   • 展开 stdio.h 文件内容，和源码一起，放到 xxx.i 文件中
   • 不检查语法错误！可以在此阶段提升任意文件
   • 测试命令：gcc -E hello.c -o hello.i -I（大）.（当前目录）

2. 宏定义替换

   • 将宏名，替换成宏值
   • #define PI 3.14【解释】：define：创建宏。PI：宏名 3.14：宏值

   1
   // 测试案例。使用命令： gcc -E hello.c -o hello.i
   2
   #include <stdio.h>
   3
   
   4
   // 定义宏
   5
   #define PI 3.14
   6
   
   7
   int main(void)
   8
   {
   9
       printf("hello world\n");
   10
   
   11
       // 使用宏
   12
       printf("PI = %f\n", PI);
   13
   
   14
       return 0;
   15
   }

3. 替换注释

   • 把单行、多行注释替换成空行

4. 展开条件编译

   • 根据条件来展开代码

   1
   // 测试案例
   2
   #include <stdio.h>
   3
   
   4
   // 定义宏
   5
   // #define PI 3.14   // PI 定义与否，直接决定下面的 -----666 是否打印。
   6
   
   7
   int main(void)
   8
   {
   9
       printf("hello world\n");
   10
   
   11
       // 使用宏
   12
       //printf("PI = %f\n", PI);
   13
   
   14
       // 使用条件编译，含义是：如果定义了 PI ，那么就打印 -----666，否则不打印。
   15
       #ifdef PI
   16
           printf("-----------------6666\n");
   17
       #endif
   18
           return 0;
   19
   }

编译#

• 参数：-S
• 生成的文件：xxx.s 汇编文件
• 使用命令：gcc -S xxx.i -o xxx.s
• 工具：编译器（包含在 gcc 编译集合工具中）

完成的工作：

1. 逐行检查语法错误！【重点】 —— 编译过程整个 gcc 编译 4 步骤中，最耗时
2. 将 C 程序翻译成汇编指令。得到 .s 汇编文件

1
.file    "hello.c"
2
.text
3
.def    ___main; .scl    2; .type    32; .endef
4
.section .rdata,"dr"
5
.LC0:
6
    .ascii "hello world\0"
7
.LC2:
8
    .ascii "PI = %f\12\0"
9
.LC3:
10
    .ascii "-----------------6666\0"
11
    .text
12
    .globl  main
13
    .def    main; .scl    2; .type    32; .endef
14
    .seh_proc   main
15
main:
16
    pushq   %rbp
17
    .seh_pushreg    %rbp
18
    movq    %rsp, %rbp
19
    .seh_setframe   %rbp, 0
20
    subq    $32, %rsp
21
    .seh_stackalloc 32
22
    .seh_endprologue
23
    call    ___main
24
    leaq    .LC0(%rip), %rcx
25
    call    puts
26
    movq    %rcx, %rax
27
    movq    %rdx, %xmm1
28
    movq    %rax, %rdx
29
    leaq    .LC2(%rip), %rcx
30
    call    printf
31
    leaq    .LC3(%rip), %rcx
32
    call    puts
33
    movl    $0, %eax
34
    addq    $32, %rsp
35
    popq    %rbp
36
    ret
37
    .seh_endproc
38
    .section .rdata,"dr"
39
    .align 8
40
.LC1:
41
    .long   1374389535
42
    .long   1074339512
43
    .ident  "GCC: (x86_64-posix-sjlj-rev0, Built by MinGW-W64 project) 8.1.0"
44
    .def    puts; .scl    2; .type    32; .endef
45
    .def    printf; .scl    2; .type    32; .endef

汇编#

• 参数：-c
• 生成的文件：xxx.o 目标文件（二进制，人类看不懂）
• 使用命令：gcc -c xxx.s -o xxx.o
• 工具：汇编器（包含在 gcc 编译集合工具中）
• 完成的工作：
  • 翻译：将汇编指令翻译成对应的二进制指令

连接#

• 参数：无（-o 不是链接阶段参数，是用来指定文件名）
• 生成的文件：xxx.exe 可执行文件（二进制，人类看不懂）
• 使用命令：gcc xxx.o -o xxx.exe
• 工具：链接器（包含在 gcc 编译集合工具中）
• 完成的工作：
  • 库引入
  • 合并并目标文件
  • 合并并启动例程

1
# 完整 4 步骤编译流程
2
gcc -E hello.c -o hello.i
3
gcc -S hello.i -o hello.s
4
gcc -c hello.s -o hello.o
5
gcc hello.o -o hello.exe
6

7
# 一句话完成
8
gcc hello.c -o hello.exe

小结#

gcc 编译的 4 个步骤中，每个步骤直接都可相互转换。

flowchart LR
    SRC["源文件 hello.c"] -.->|gcc hello.c -o hello.exe| EXE["可执行文件 hello.exe"]
    SRC -.->|-E| PRE["预处理"]
    PRE -->|-S| COM["编译"]
    COM -->|-c| ASM["汇编"]
    ASM -->|无参| LINK["链接"]
    LINK --> EXE
    SRC -.->|-S| COM
    SRC -.->|-c| ASM
    SRC -.->|无参| LINK

程序调试流程#

1. 添加断点。——可以添加多个
   1. 鼠标点击待添加断点行，左侧行号前灰色区域。再次点击取消
   2. 光标停止在待添加断点行的任意位置，按 F9 添加断点。再次按 F9 取消断点
2. 测试，必须在 Debug 模式下进程。Release 模式无效
3. F5 启动调试
4. 断点停止的位置，是尚未执行的指令
5. 开始调试：
   1. 逐语句执行。逐语句执行下一行（F11）：遇见函数，进入自定义函数内部，逐条跟踪执行
   2. 逐过程执行。逐过程执行下一行（F10）：遇见函数，不进入函数内部，逐条跟踪执行
   3. 逐断点执行。代码中有多个断点，直接跳转至下一个断点。—— 点击”继续”，无快捷键
   4. 跳出函数。跳出当前断点所在的函数。shift + F10

变量 3 要素#

1. 变量名：用来在程序中使用
2. 变量类型：开辟内存空间大小
3. 变量值：存储的实际数据

flowchart LR
    MEM["内存"]
    MEM --> A["a 空间大小：4字节 变量类型：int 变量值：10 10"]
    MEM --> B["b 空间大小：4字节 变量类型：int 变量值：20 20"]

变量定义#

• 定义语法：类型名 变量名 = 变量值（一般定义方法），int m = 57;
• 会开辟内存空间给变量。变量声明不会开辟内存空间。

变量声明#

• 语法：
  • int a; 没有变量值的变量定义，叫做声明
  • extern int a; 添加 extern 关键字
• 特性：
  • 变量要想使用，必须有定义
  • 编译器，在使用变量之前，必须能看到变量定义。如果没有看到，编译器会自动寻找一个变量声明。提升成定义
  • 如果 变量声明前，添加了 extern 关键字，无法提升！

硬性要求#

1. 标识符不能是关键字、函数名。 system、printf、int、main、return、..
2. 只能有字母、数字、下划线组成。 a-z/A-Z/0-9_
   • abc_1/abc_2/_abc_1/a_b_c_d
3. 不能以数字开头。
   • int a5ir = 10; ok
   • int _34F = 6; ok
   • float 98i_54 = 5.4; error
4. 大小写严格区分。
   • 通常 使用大写来定义常量。#define MAX 100
   • 通常 使用小写来定义变量

命名规范#

1. 大驼峰法：int HelloWorldHahaHohoHehe = 10;
   • 多个单词组成变量名，每个单词首字母大写
2. 小驼峰法：int helloWorldHahaHohoHehe = 10;
   • 多个单词组成变量名，首个单词的首字母小写，其余每个单词首字母大写
3. 小写 + 下划线：int hello_world_haha_hoho_hehe = 10;
   • C 语言专用！

有符号整型#

获取数据类型的最小值、最大值，可以使用 #include <limits.h>

1
#include <stdio.h>
2
#include <limits.h>
3

4
int main(void)
5
{
6
    printf("int大小 = %u\n", sizeof(int));
7
    printf("int最小值: %d, 最大值: %d\n", INT_MIN, INT_MAX);
8

9
    printf("short大小 = %u\n", sizeof(short));
10
    printf("short最小值: %hd, 最大值: %hd\n", SHRT_MIN, SHRT_MAX);
11

12
    printf("long大小 = %u\n", sizeof(long));
13
    printf("long最小值: %ld, 最大值: %ld\n", LONG_MIN, LONG_MAX);
14

15
    printf("long long大小 = %u\n", sizeof(long long));
16
    printf("long long最小值: %lld, 最大值: %lld\n", LLONG_MIN, LLONG_MAX);
17

18
    return 0;
19
}

无符号整型#

基础信息#

• 字符型
• 单位：一个字节（8 bit 位）
• 格式匹配符：
  • 数值型：
    • 有符号：%hhd —— char 显示数值专用格式匹配符
    • 无符号：%hhu —— unsigned char 显示数值专用格式匹配符
  • 字符型：%c
• 取值范围：
  • 有符号：-128 ~ 127
  • 无符号：0 ~ 255
• 程序获取：

1
#include <stdio.h>
2
#include <limits.h>
3

4
int main(void)
5
{
6
    // 获取无符号数值范围
7
    printf("char 无符号 min = 0, max = %hhu\n", UCHAR_MAX);
8
    // 获取有符号数值范围
9
    printf("char 有符号 min = %hhd, max = %hhd\n", CHAR_MIN, CHAR_MAX);
10
    // 获取 char 占用的字节数
11
    printf("char 大小 = %u\n", sizeof(char));
12
    // 获取 unsigned char 占用的字节数
13
    printf("unsigned char 大小 = %u\n", sizeof(unsigned char));
14

15
    return 0;
16
}

ASCII 码#

• char 类型数据，数值对应一个 ASCII 码
• ASCII 表（American Standard Code for Information Interchange 美国标准信息交换代码）

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    char ch = 'A';   // 定义变量 ch, 指定初值为 'A';
6

7
    printf("ch = %c\n", ch);   // c: character. %c 用来显示字符的 格式匹配符。
8

9
    ch = 'm';     // 给变量 ch 赋值成 'm', 覆盖 原来的 'A';
10

11
    printf("ch = %c\n", ch);
12

13
    ch = 97;     // 使用 范围内的数值 97, 给 ch 赋值.
14

15
    printf("ch = %c\n", ch);   // 将数值97, 按照字符格式打印输出。
16

17
    ch = 98;     // 使用 范围内的数值 98, 给 ch 赋值.
18

19
    printf("ch = %c\n", ch);   // 将数值98, 按照字符格式打印输出。
20

21
    return 0;
22
}

练习#

将大写字母，转换成小写字母：

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    char ch = 'R';   // char 变量定义
6

7
    printf("R 转换的小写为: %c\n", ch+32);   // ch+32 表达式，对应格式匹配符 %c
8

9
    char ch2 = 'h'; // char 变量定义
10

11
    printf("h 转换的大写为: %c\n", ch2-32); // ch2-32 表达式，对应格式匹配符 %c
12

13
    char ch3 = '5';
14
    // 借助字符 5, 利用 ASCII特性, 打印出 字符9
15
    printf("打印字符9 = %c\n", ch3+4);
16

17
    return 0;
18
}

ASCII 表说明#

• 0 ~ 32 ASCII 码 对应的字符都不可见
• 常用的 ASCII 码：
  • 'a'：ASCII 码值 97
  • 'A'：ASCII 码值 65
  • '0'：ASCII 码值 48
  • '\n'：ASCII 码值 10
  • '\t'：制表符。tab 键对应的字符。（ASCII 码值 9）
  • '\0'：ASCII 码值 0

char 与 printf 对应关系#

flowchart LR
    A["char ch = 'A';"] --> CH["'A'"]
    CH -->|"%hhd / %d / %hd"| V["65 打印 ch 对应的值"]
    CH -->|"%c"| C["A 打印 ch 对应的字符"]

练习：在一个 printf 函数中，打印输出 hello 换行 world 换行

1
// 方法 1
2
int main(void)
3
{
4
    printf("hello\nworld\n");
5
    return 0;
6
}
7

8
// 方法 2
9
int main(void)
10
{
11
    char ch = '\n'; // 定义 ch 变量，初值为 '\n'
12

13
    printf("hello%cworld%c", ch, ch); // 等价于 printf("hello\nworld\n");
14

15
    return 0;
16
}

一个 printf 中打印 hello（一个 tab 缩进）world 换行：

1
int main(void)
2
{
3
    char ch1 = '\t';   // 实现 一个 tab 缩进
4
    char ch2 = '\n';   // 实现 一个换行
5

6
    printf("hello%cworld%c", ch1, ch2);
7

8
    return 0;
9
}

转义字符#

• '/'：自右向左划，叫做「斜杠」
• '\'：自左向右划，叫做「反斜杠」。—— 是转义字符
• 转义字符的作用：
  1. 将普通字符，转换为 特殊意
     • 如：'\n'：这是一个字符，代表换行
     • 如：'\t'：这是一个字符，代表一个制表符
  2. 将特殊字符，还原成本身意
     • 如：'\\n'：这样就将一个字符 \n，还原成 两个字符：'\' 和 'n'

练习：将特殊字符转换成本身意。

题目：屏幕上严格输出 如下内容：【“\n”的值是 10】要求显示时要有 "

1
int main(void)
2
{
3
    printf("\"\\n\"的值是 %hhd", '\n');
4
    return 0;
5
}

基础信息#

• float：单精度浮点型。%f 大小：4 字节。（可以使用 sizeof() 求取）
  • 4.35 默认会被编译器理解为 double 类型
  • float v = 4.567f;：编译器理解 float
  • %f 格式匹配符，默认保留 6 位小数
• double：双精度浮点型。%lf 大小：8 字节。
  • double d = 5.68;

取值范围#

使用头文件 #include <float.h> 获取浮点型取值范围：

1
int main(void)
2
{
3
    printf("float 范围: %f ~ %f\n", FLT_MIN, FLT_MAX);
4
    printf("double 范围: %lf ~ %lf\n", DBL_MIN, DBL_MAX);
5

6
    return 0;
7
}

精度问题#

• float 类型：
  • 精度 6~7 位
    • 整数部分 + 小数部分 <= 6 位，准确
    • 整数部分 + 小数部分 == 7 位，可能准确，也可能不准确
    • 整数部分 + 小数部分 > 7 位，不准确
• double 类型：
  • 精度 15~16 位
    • 整数部分 + 小数部分 <= 15 位，准确
    • 整数部分 + 小数部分 == 16 位，可能准确，也可能不准确
    • 整数部分 + 小数部分 > 16 位，不准确

1
int main(void)
2
{
3
    float f = 439243243.9f;
4

5
    printf("f = %f\n", f);
6

7
    return 0;
8
}

不同平台（操作系统），对应 float、double 类型实现的精度有可能不同。以上是 Windows 下特性。

float 和 double 不存在”无符号”类型。

存储知识#

• 1 bit 位 就是一个 二进制位，存 0 或 1
• 一个字节（Byte） 1B = 8 bit 位
• “内存单元” 是计算机内存存储的最小单位，一个内存单元 == 1 字节
• 1KB = 1024B
• 1MB = 1024KB
• 1GB = 1024MB
• 1TB = 1024GB

2 进制#

• 取值 1 或 0，逢 2 进 1，借 1 当 2
• 没有格式匹配符

10 转 2：

• 除 2 反向取余法

示例：56 → 111000；173 → 1010 1101

2 转 10：

• 掌握 2⁰ ~ 2¹⁰ 各自的取值：

• 计算方法，对应二进制位，有 1 累加 2 的指数次幂值，有 0 略过

11101 —— 29

10110 —— 2+4+16 = 22

8 进制#

• 逢 8 进 1，借 1 当 8
• 取值：0/1/2/3/4/5/6/7 最大值 7
• 格式匹配符：%o 和 %#o
• 表示语法：0 开头
• 8 进制 ——> 10 进制：
  • 056 == 8⁰ * 6 + 8¹ * 5 = 6 + 40 = 46
  • 0123 = 8⁰ * 3 + 8¹ * 2 + 8² * 1 = 3 + 16 + 64 = 83
• 10 进制 ——> 8 进制：
  • 除 8 反向取余法
  • 135 —— 0207

8 转 2：

• 转换算法：将 8 进制数，自左向右，每一位，用 421 码展开
• 练习：
  • 056 —— 101110
  • 04735 —— 1001 1101 1101
  • 053261 —— 101 0110 1011 0001

2 转 8：

• 转换方法：自右向左，每 3 个二级制位一组，不足 3 位补 0
  • 1101010101111010
    • 分组：1 101 010 101 111 010
    • 补齐：001 101 010 101 111 010
    • 八进制数为：0152572
  • 101101111011
    • 分组：10 110 111 011
    • 补齐：010 110 111 011
    • 八进制数为：02673

16 进制#

• 逢 16 进 1，借 1 当 16
• 取值：0~9 10-A/a 11-B/b 12-C/c 13-D/d 14-E/e 15-F/f 最大值：F/f
• 格式匹配符：%x 或 %#x
• 表示语法：0x 开头
• 16 进制 ——> 10 进制：
  • 将每一个 16 进制位，展开 相加得 10 进制
• 10 进制 ——> 16 进制：
  • 除 16 反向取余法
  • 37：0x25
  • 43：0x2B

16 转 2：

• 转换算法：将 16 进制数，自左向右，每一位，用 8421 码展开
  • 0xFAC12：1111 1010 1100 0001 0010

2 转 16：

• 转换方法：自右向左，每 4 个二级制位一组，不足 4 位补 0
  • 101001011101011001
    • 分组：10 1001 0111 0101 1001
    • 补齐：0010 1001 0111 0101 1001
    • 16 进制数为：0x29759
  • 1110110100111101
    • 分组：1110 1101 0011 1101
    • 补齐：1110 1101 0011 1101
    • 16 进制数为：0xED3D

小结#

• 使用频率最高的是 10 进制。其次是：16 进制
  • int m = 0x15f4;
  • int n = 0345;
  • int k = 01011101;
    • 不能直接将变量值赋值为 2 进制
    • 上述的赋值，会被编译器理解为 8 进制数

1
#include <stdio.h>
2

3
int main(void)
4
{
5
    int a = 56;   // 10 进制数作 a 变量初始化。 -- 定义。
6

7
    printf("10进制: a = %d\n", a);
8
    printf("8进制: a = %o\n", a);
9
    printf("8进制: a = %#o\n", a);  // 在 % 和 #o 中间添加#，可以在输出时，显示 8 进制前缀。
10
    printf("16进制: a = %x\n", a);
11
    printf("16进制: a = %#x\n", a); // 在 % 和 #x 中间添加#，可以在输出时，显示 16 进制前缀。
12

13
    return 0;
14
}

常用的格式匹配符#

无符号存储#

1
unsigned int a = 12;   // 占用 4 字节 32 个 bit 位存储。
2
空间: 00000000 00000000 00000000 00000000   ----  4 字节。
3
存储: 00000000 00000000 00000000 00001100
4

5
unsigned short b = 15;   // 占用 2 字节 16 个 bit 位存储。
6
空间: 00000000 00000000                ----  2 字节。
7
存储: 00000000 00001111

有符号存储#

• 需要拿出一个二进制位，专门存储符号。标识正、负
  • 选用最高位 为符号位
  • 正：0
  • 负：1

有符号正数：

1
// 采用 "源码" 存储
2
int a = 5;
3
空间: 0 0000000 00000000 00000000 00000000
4
存储: 0 0000000 00000000 00000000 00000101   --- 表示存储正数 5 。

有符号负数：

• 有符号的负数，采用「补码」存储
  • 源码：数值的二进制制直接存储
  • 反码：符号位不变，将其余数值位取反
  • 补码：反码 + 1

1
int b = -33;
2
空间: 0 0000000 00000000 00000000 00000000
3
源码: 1 0000000 00000000 00000000 00100001
4
反码: 1 1111111 11111111 11111111 11011110
5
补码: 1 1111111 11111111 11111111 11011111   --- 负 33 在计算机中实际的存储形式。

• 小结：
  • int —— 4 字节 —— 32 bit 位
    • 有符号：31 个数值位，取值范围 -2³¹ ~ 2³¹ - 1 ——> -2147483648 ~ +2147483647
    • 无符号：32 个数值位，取值范围 0 ~ 2³² - 1 ——> 0 ~ 4294967295
  • short —— 2 字节 —— 16 bit 位
    • 有符号：15 个数值位，取值范围 -2¹⁵ ~ 2¹⁵ - 1 ——> -32768 ~ 32767
    • 无符号：16 个数值位，取值范围 0 ~ 2¹⁶ - 1 ——> 0 ~ 65535
• 因此，知道数据类型占用内存的大小，就能算出该类型 无符号数、有符号数 对应的取值范围。

无符号数#

• 取值范围 0 ~ 2³² - 1
• 最大值 + 1 ——> 0
• 0 - 1 ——> 最大值

1
// 上溢出
2
int main(void)
3
{
4
    unsigned int a = UINT_MAX;   // 取出无符号最大值
5

6
    printf("最大值+1 = %d\n", a + 1);  // 0
7
    printf("最大值+2 = %d\n", a + 2);  // 1
8

9
    return 0;
10
}
11

12
// 下溢出
13
int main(void)
14
{
15
    unsigned int a = 0; // 取出无符号最小值
16

17
    printf("最小值-1 = %u, 最大值 = %u\n", a - 1, UINT_MAX);
18

19
    return 0;
20
}

有符号数#

上溢出：

• 最大值 + 1，下溢出 == 最小值

1
// unsigned 上溢出。
2
int main(void)
3
{
4
    int a = INT_MAX;   // 取出无符号最小值
5

6
    printf("最大值+1 = %d, 最小值 = %d\n", a+1, INT_MIN);
7

8
    return 0;
9
}
10

11
// signed 上溢出。
12
int main(void)
13
{
14
    int a = INT_MAX;   // 取出有符号最小值
15

16
    printf("最大值+1 = %d, 最小值 = %d\n", a+1, INT_MIN);
17

18
    return 0;
19
}

下溢出：

• 最小值 - 1，下溢出 == 最大值

1
// signed 下溢出。
2
int main(void)
3
{
4
    int a = INT_MIN;   // 取出有符号最小值
5

6
    printf("最小值-1 = %d, 最大值 = %d\n", a - 1, INT_MAX);
7

8
    return 0;
9
}

小结#

• 大部分编译器，对于数值溢出，采用上述处理方式。但，个别编译器有可能不能
• 受数值溢出影响，进行数据存储时，要选择恰当的数据类型。389482390483209 —— int

输出函数#

• printf()：%d, %c, %x, %u, %s ...
• putchar() 函数：
  • 输出一个字符到屏幕
  • 'abcZ' 是错误的定义，既不是 char 也不是字符串

1
putchar(97);     // 97 == 'a'
2

3
putchar('\n');   // 输出换行符。
4

5
putchar('b');
6

7
putchar('\n');   // 使用率较高。  printf("\n");
8

9
putchar('abcZ'); // 'abcZ' 是错误的定义，既不是 char 也不是字符串。

输入函数#

1
int a;   // 可以定义 a 变量（有内存空间），也可以声明（自动提升成定义，有内存空间）
2
scanf("%d", &a);     // &: 取变量 a 的地址 ---> 拿到 a 的内存空间。

1
// scanf 输入
2
int main(void)
3
{
4
    //int a = 10;
5
    int a;   // 在 scanf 执行时，会提升为定义。
6

7
    int ret = scanf("%d", &a);  // scanf 可以从键盘获取用户输入，用户根据 %d 输入整数。
8

9
    printf("获取的a为: %d\n", a);
10

11
    return EXIT_SUCCESS;
12
}

1
int a, b, c;   // 一次性创建多个 int 类型变量。
2

3
// scanf 可以从键盘获取用户输入，用户根据 多个%d 输入整数。
4
int ret = scanf("%d%d%d", &a, &b, &c);
5

6
// 上述写法编译器无法识别。输入的 123 应该怎样分配给 3 个 %d

1
int main(void)
2
{
3
    int a, b, c;   // 一次性创建多个 int 类型变量。
4

5
    // scanf 可以从键盘获取用户输入，用户根据 多个%d 输入整数。
6
    int ret = scanf("%d %d %d", &a, &b, &c);
7

8
    printf("获取的a为: %d\n", a);
9
    printf("获取的b为: %d\n", b);
10
    printf("获取的c为: %d\n", c);
11

12
    return EXIT_SUCCESS;
13
}

1
// scanf 输入，获取字符。
2
int main(void)
3
{
4
    char ch1, ch2, ch3;   // 一次性创建多个 char 变量
5

6
    printf("请输入3个字符，用空格隔分: ");
7

8
    scanf("%c %c %c", &ch1, &ch2, &ch3);
9

10
    printf("ch1 = %c\n", ch1);
11
    printf("ch2 = %c\n", ch2);
12
    printf("ch3 = %c\n", ch3);
13

14
    return EXIT_SUCCESS;
15
}

1
int main(void)
2
{
3
    char ch = getchar();  // 定义 char 变量 ch, 接收 getchar() 函数返回值做为初值。
4

5
    printf("ch的数值: %d\n", ch);   // %hhd %hd
6
    printf("ch的字符: %c\n", ch);
7

8
    return EXIT_SUCCESS;
9
}

算数运算符#

1. + - * /：先乘除取余，后加减
2. 除法运算后，得到的结果赋值给整型变量，取整数部分。int c = 10/20; ——> 0
3. 除 0：错误操作，不允许。printf("%d\n", 10/0);
4. 对 0 取余：错误操作，不允许。printf("%d\n", 123 % 0);
5. 不允许对小数取模。35 % 3.4;
6. 对负数取余，结果为余数的绝对值。printf("%d\n", 10 % -3); ——> 1

自增自减运算符#

• 前缀自增 (++)，自减 (—)

  • 先自增、自减，再取值

    1
    int a = 10;
    2
    ++a;  // 等价于  a = a+1;

• 后缀自增 (++)，自减 (—)

  • 先取值，再自增、自减

1
// ++ / -- 运算符
2
int main(void)
3
{
4
    // 前缀
5
    int a = 10;
6
    printf("%d\n", ++a);  // ++a 等价于 a = a+1;
7

8
    // 后缀
9
    int b = 10;
10
    printf("%d\n", b++);  // b++ 等价于 b = b+1;
11

12
    // 不管前缀、后缀、含有变量 ++/-- 表达式执行完后，变量均发生了自增、自减。
13
    printf("b = %d\n", b);
14

15
    return EXIT_SUCCESS;
16
}

赋值运算符#

1. =，在计算机中，只能完成”赋值”操作，一定是右边赋值给左边，也叫单向赋值
2. a += 10 // 等价于 a = a+10;
3. a -= 30 // 等价于 a = a-30;
4. a %= 5; // 等价于 a = a%5;

比较运算符#

• 真：1（非 0），假：0
• == 判等符（= 不是用来判等）
• != 不等
• < 小于
• <= 小于等于
• > 大于
• >= 大于等于
• 【强调】：数学运算中 13 < var < 16 判断，在计算机中，要写成：var > 13 && var < 16;

逻辑运算符#

• 0 为假，非 0 为真。（非 0：1、27、-9）

• 逻辑非（!）

  • 非真为假，非假为真

    1
    // 逻辑运算符
    2
    int main(void)
    3
    {
    4
        // 逻辑非
    5
        int a = 34;  // 34 是非0， 默认 a 为真。
    6
        int b = 0;
    7
    
    8
        printf("!a = %d\n", !a);  // a 为真，非a 为假！ ---> 0
    9
        printf("b = %d\n", !b);   // b=0，b 为假，非b，为真。 ---> 1
    10
    
    11
        return EXIT_SUCCESS;
    12
    }

• 逻辑与（&&）

  • 同真为真，其余为假

    1
    printf("=====&&%d\n", a && !b);  // a为真，!b为真，真&&真 -- 真。 ----> 1

• 逻辑或（||）

  • 有真为真，同假为假

    1
    printf("-----||%d\n", a || b);   // a 为真，!b 为真，真||真 -- 真。 ---> 1
    2
    printf("------%d\n", !a || b);   // !a 为假，b 为假，假||假 -- 假。 ---> 0
    3
    printf("-----||%d\n", !a || !b); // !a 为假，b 为假，假||假 -- 假。 ---> 0

运算符优先级#

() > ++/--（后缀高于前缀）(强转) ! (逻辑非) sizeof > 算数运算符(先乘除取余，后加减) > 比较运算符 > 逻辑运算符 > 三目运算（条件运算）> 赋值运算符 > 逗号运算符

• 一周左右的时间，记忆运算符优先级

逗号运算符#

1
int x, y, z;
2
int a = (x=1, y=2, z=3);  // x=1, y=2, z=3 是一个逗号运算符表达式。运算结果为 a = 3;
3

4
int a = (x=1, z=3, y=2?);  // 运算结果为 a = 2?;

• 含有”,” 运算符表达式运算结果，是最后一个子表达式的结果

三目运算符#

• 语法：表达式1 ? 表达式2 : 表达式3
  • 表达式 1 必须是一个判断表达式
  • 结果为真：整个三目运算，返回表达式 2
  • 结果为假：整个三目运算，返回表达式 3

1
// 三目运算
2
int main(void)
3
{
4
    int a = 40;
5
    int b = 4;
6

7
    //int m = a > b ? 69 : 10;
8
    //printf("m = %d\n", m);  // m = 69;
9

10
    //int m = a < b ? 69 : 10;
11
    //printf("m = %d\n", m);   // m = 10;
12

13
    // 三目运算支持嵌套
14
    int m = a < b ? 69 : (a<b?3+5); // 先算表达式3，加5，整个三目运算，取表达式3-->5
15
    printf("m = %d\n", m);   // m = 5;
16

17
    int m = a < b ? 69 : a < b ? 3 : 5;
18
    printf("m = %d\n", m);   // m = 5;
19

20
    return EXIT_SUCCESS;
21
}

• 如果不使用 ()，三目运算默认的结合性，自右向左

隐式类型转换#

1. 编译器自动完成。（小类型转大类型，同类型大小）

flowchart TB
    D["高 double"] --> L["long"]
    L --> UI["unsigned int"]
    UI --> SI["低 signed int"]
    CH["char, short"] --> SI
    F["float"] --> D

2. 由赋值产生：

1
int r = 3;
2
float s = 3.14 * r * r;
3
// 3.14 默认类型是 double, r 是 int 类型。运算过程中，转换为 double 类型运算。
4
// 运算结束，赋值给 s 时，转换为 float。

• 小类型 ——> 大类型。没问题
• 大类型 ——> 小类型。可能丢失数据
  • VS 中 Ctrl + F7 只编译，检查语法错误，不运行

1
int main(void)
2
{
3
    int a = 321;
4
    char ch = a;   // 用值为 321 的a变量，给 char 类型赋值。
5

6
    printf("ch = %d\n", ch);   // 运行输出 65;
7

8
    return EXIT_SUCCESS;
9
}

321：2⁸=256 有，128 没有，64 有，32/16/8/4/2 没有，有 1

0000 0000 0000 0000 0000 0001 0100 0001 —— 321 二进制表现形式

0000 0000 —— char 只有一个字节。

赋值后，char 值为：0100 0001 --- 1 + 64 = 65

强制类型转换#

• 语法：
  1. 强制变量：(目标类型) 变量
  2. 强制表达式：(目标类型) 表达式

1
int main(void)
2
{
3
    float price = 3.6;   // 单价
4
    int weight = 4; // 斤数
5

6
    //int sum = weight * (int)price;   // 强制变量。
7
    //printf("sum = %d\n", sum);  // --- 12
8

9
    int sum = (int)(weight * price);   // 强制表达式。
10
    printf("sum = %d\n", sum);  // --- 14
11

12
    return EXIT_SUCCESS;
13
}