第1页 / 共130页
第2页 / 共130页
第3页 / 共130页
第4页 / 共130页
第5页 / 共130页
第6页 / 共130页
第7页 / 共130页
第8页 / 共130页
C语言深度进阶篇-王桂林-.pdf
1.数据类型
1.1.内存
1.2.补码
1.2.1.运算规则
1.2.2.补码特点
1.2.3.char(8位)补码的展示
1.3.数据类型
1.3.1.数据类型
1.3.2.范围计算
1.3.2.1.整型
1.3.2.2.实型
1.3.3.数据类型是对内存的格式化
1.4.类型转化
1.4.1.类型转化的原理
1.4.1.1.小数据赋给大变量
1.4.1.2.大数据赋给小变量
1.4.2.隐式转化
1.4.2.1.整型提升
1.4.2.2.混合提升
1.4.3.显示(强制类型)转化
1.5.练习
1.5.1.下面的代码输出什么？
1.5.2.以下程序输出什么？
2.进程空间
2.1.进程空间
2.2.进程/程序
2.2.1.程序
2.2.2.进程
2.2.3.进程到程序
2.3.数据在进程空间的存储
2.3.1.示意图
2.3.2.数据在进程空间
2.4.函数的压栈与出栈
2.4.1.普通函数
2.4.2.递归函数
2.5.课堂实战
2.5.1.如下程序中数据存储在哪里
2.5.2.用递归正/逆序打印一个数组
3.数组
3.1.一维数组
3.1.1.本质
3.1.2.初始化
3.1.3.访问
3.1.3.1.数组名作整体访问
3.1.3.2.数组名作起始地址访问成员
3.1.4.作参数传递
3.1.5.返回堆中一维数组
3.1.5.1.返回值返回(一级指针)
3.1.5.2.参数返回(二级指针)
3.1.6.练习
3.1.6.1.合并有序数组使其依然有序
3.1.6.2.求最值
3.1.6.3.求次最值
3.2.二维数组
3.2.1.本质
3.2.2.初始化
3.2.3.访问
3.2.3.1.数组名作为整体访问
3.2.3.2.数组名作起始地址访问成员
3.2.3.3.结论
3.2.4.线性存储
3.2.5.作参数传递
3.3.数组指针
3.3.1.引入
3.3.2.定义
3.3.3.别名
3.3.4.数组指针与数组名
3.3.5.应用
3.3.5.1.二维数组传参
3.3.5.2.一维空间的二维访问
3.4.多维数组
3.4.1.本质分析
3.4.2.形像描述
3.5.课堂实战
3.5.1.求值?
3.5.2.下面代码的值为多少？
4.指针
4.1.内存编址与变量地址
4.1.1.编址
4.1.2.变量地址
4.2.指针与指针变量
4.2.1.指针的本质
4.2.2.指针变量
4.2.2.1.变量大小
4.2.2.2.变量类型
4.2.2.3.引用与解引用
4.2.2.4.运算
4.2.3.课堂实战
4.3.二级指针
4.3.1.定义与初始化
4.3.2.间接数据访问
4.3.2.1.改变一级指针指向的内容
4.3.2.2.改变一级指针指向
4.3.2.3.改变N-1级指针的指向
4.3.3.初始化一级指针
4.3.3.1.从FILE *到sqlite3*
4.3.3.2.原理剖析
4.3.4.二级指针的步长
4.4.指针数组(字符指针数组)
4.4.1.定义
4.4.2.使用
4.4.3.二级指针访问指针数组
4.4.3.1.指针数组名赋给二级指针的合理性
4.4.3.2.完美匹配的前提(小尾巴NULL)
4.4.4.常见指针数组
4.4.4.1.char**argv与char*argv[]
4.4.4.2.char **env与char*env[]
4.5.指针的输入与输出
4.6.堆上一维空间
4.6.1.返回值返回(一级指针)
4.6.2.参数返回(二级指针)
4.7.堆上二维空间
4.7.1.一级指针作返值输出
4.7.2.二级指针作返值输出
4.7.2.1.空间申请
4.7.2.2.空间释放
4.7.3.三级指针作参数输出
4.7.4.课堂练习
4.7.4.1.序列加密
4.7.4.2.读文件到内存
4.8.const修饰指针
4.8.1.const 修饰变量
4.8.2.const 修饰符
4.8.3.const 修饰指针指向
4.8.4.应用(修饰函数参数)
4.9.练习
4.9.1.请手写下面代码的输出结果。
4.9.2.天生棋局
5.函数
5.1.函数多参返回
5.1.1.引列
5.1.2.正解
5.2.函数指针
5.2.1.函数的本质
5.2.2.函数指针变量定义与赋值
5.2.3.函数指针类型定义
5.2.4.函数类型别名
5.2.5.函数指针调用
5.2.6.函数指针数组
5.2.6.1.定义
5.2.6.2.应用场景
5.3.回调函数
5.3.1.问题引出
5.3.2.回调(函数作参数)
5.3.3.本质论
5.3.4.qsort
5.3.4.1.函数接口
5.3.4.2.回调函数例举
5.3.4.3.课堂练习
5.4.练习
5.4.1. (*(void(*) ()) 0)();
6.再论指针与数组
6.1.一级指针与一维数组名
6.1.1.等价条件
6.1.2.便利访问
6.2.二级指针与指针数组名
6.2.1.等价条件
6.2.2.便利访问
6.2.3.通过二级指针申请二维空间
6.3.数组指针与二维数组名
6.3.1.等价条件
6.3.2.便利访问
6.4.关于二级指针与二维数组名
6.5.对数组名的引用
6.5.1.一维数组
6.5.2.二维数组
6.6.小结与练习
6.6.1.指针-数组-函数
6.6.2.请写出右边的示意
6.6.3.传参汇总
6.6.4.写出程序的运行结果
7.基于数组排序(提高篇)
7.1.选择优化
7.1.1.选择原理与步骤
7.1.2.代码实现
7.1.3.优化升级
7.2.冒泡优化
7.2.1.冒泡原理与步骤
7.2.2.代码实现
7.2.3.优化升级
7.3.快速排序
7.3.1.排序原理与步骤
7.3.2.代码实现
7.4.练习
7.4.1.实现二级排序
8.基于数组的查找
8.1.线性查找
8.2.二分查找
8.2.1.原理步骤
8.2.2.迭代版(Iterative)
8.2.3.递归版(Recursive)
9.字符串
9.1.字符串常量
9.1.1.定义相关
9.1.2.c语言处理字符串
9.2.字符数组
9.2.1.字符数组与字符串
9.2.2.不等价条件
9.2.2.1.读越界
9.2.2.2.写越界
9.2.3.等价条件
9.2.4.N系列字符串函数
9.3.字符串操作函数
9.3.1.strlen
9.3.1.1.使用
9.3.1.2.自实现
9.3.2.strcpy/strncpy
9.3.2.1.使用
9.3.2.2.自实现
9.3.3.strcat/strncat
9.3.3.1.使用
9.3.3.2.自实现
9.3.4.strcmp/strncmp
9.3.4.1.使用
9.3.4.2.自实现
9.3.5.sprintf
9.3.6.atoi/itoa
9.3.7.strchr/strrchr
9.3.7.1.函数介绍
9.3.7.2.使用
9.3.7.3.统计一个字符在字符串内出现的次数
9.3.7.4.自实现
9.3.8.strcspn/strspn
9.3.9.strstr/strpbrk
9.3.9.1.函数接口
9.3.9.2.使用
9.3.9.3.统计一个字符串在另一个字符串内出现的次数
9.3.9.4.自实现1
9.3.9.5.自实现2
9.3.10.strtok
9.3.10.1.函数接口
9.3.10.2.分析入门
9.3.10.3.使用
9.3.10.4.分割字符串到二维空间
9.3.10.5.思考实现strtok
9.4.内存操作函数
9.4.1.memcpy
9.4.2.memmove
9.4.3.memcmp
9.4.4.memchr
9.4.5.memset
9.5.字符串应用案例
9.5.1.trim系列
9.5.1.1.引例
9.5.1.2.去除右空格
9.5.1.3.去除左空格
9.5.1.4.去除全空格
9.5.1.5.去除任意字符
9.5.2.递归逆置字符串
9.5.2.1.非递归实现
9.5.2.2.逆置输出一个字符串
9.5.2.3.将逆置的串保存(全局)
9.5.2.4.将逆置的串保存(局部)
9.6.练习
9.6.1.返回s2在s1中最后一次出现的位置
9.6.2.清空字符串中的制表符
9.6.3. 格式化文件
9.6.4.判断字符串s1是否是s2循环移位所得
9.6.5.求字符频度
9.6.6.压缩字符串
9.6.7.实现atoi功能
9.6.8.实现itoa功能
10.数据结构(双向循环链表)
10.1.双向循环链表存在的意义
10.2.链表构成
10.2.1.节点图示
10.2.2.节点码示
10.2.3.空链表示意
10.2.4.非空链表示意
10.3.双向循环链表静态形式
10.3.1.节点代码
10.3.2.静态模拟
10.4.双向循环链表的操作
10.4.1.创建
10.4.1.1.尾插法
10.4.1.2.头插法
10.4.2.插入
10.4.3.遍历
10.4.3.1.走next
10.4.3.2.走pre
10.4.4.求长度
10.4.5.查找
10.4.5.1.单向
10.4.5.2.双向
10.4.6.删除节点
10.4.7.排序
10.4.7.1.交换数据
10.4.7.2.交换指针
10.4.8.销毁
10.5.链表应用-贪吃蛇
10.5.1.业务逻辑
10.5.1.1.图示
10.5.1.2.细化分析
10.5.2.MVC架构分析
10.5.2.1.Model
10.5.2.2.View
10.5.2.3.Control
10.5.3.其它
10.5.3.1.非阻塞输入
10.5.3.2.精细延时
10.6.练习
10.6.1.用双向循环链表实现读文件到内存
11.动态库与静态库
11.1.函数库
11.1.1.库存在的意义
11.1.2.库的划分
11.1.3.库的命名规则
11.1.4.静/动态库特点
11.1.5.linux库存放的路径
11.1.6.使用特点
11.1.7.查看一个文件的库的使用情况
11.2.标准库的使用
11.2.1.libm.a
11.2.2.lib.so
11.2.3.比较
11.2.3.1.libm.a
11.2.3.2.libm.so
11.2.3.3.图示
11.3.自定义库的生成与使用
11.3.1.多文件编程
11.3.1.1.书写方式
11.3.1.2.理论基础
11.3.1.3.实战案例
11.3.2.静态库的生成与使用
11.3.2.1.步骤
11.3.2.2.实战
11.3.3.动态库的生成与使用
11.3.3.1.步骤
11.3.3.2.实战
11.3.3.3.链接路径
11.3.3.4.运行路径
11.4.gcc的编译选项
12.配置文件读写
12.1.文件回顾
12.1.1.文件基础
12.1.1.1.流
12.1.1.2.文本文件与二进制文件
12.1.1.3.缓冲
12.1.2.文件操作
12.1.2.1.一次读写一个字符
12.1.2.2.一次读写一行字符
12.1.2.3.一次读写一块
12.1.2.4.格式化读写
12.2.链表回顾
12.2.1.节点
12.2.2.创建
12.2.3.插入
12.2.4.求长
12.2.5.查找
12.2.6.删除
12.2.7.排序
12.2.8.销毁
12.3.字符串处理回顾
12.3.1.常规处理
12.3.2.去空处理
12.4.实现登录系统
12.4.1.链表节点设计
12.4.2.读文件并处理字符串
12.4.3.登录
13.SQLite
13.1.本章综旨
13.2.SQLite简介
13.3.数据库基本概念
13.4.官网与下载
13.5.SQLite管理操作
13.5.1.进入sqlite3交互模式
13.5.2.创建销毁表
13.5.2.1.示例
13.5.2.2.解析：
13.5.2.3.补充：
13.5.3.插入与查询
13.5.4.排序
13.5.5.修改与删除记录
13.5.6.备份与恢复
13.5.6.1.备份数据库
13.5.6.2.恢复数据库
13.5.6.3.复制数据库
13.5.7.Navicat for SQLite
13.6.Vs/Qt+SQLite配置
13.6.1.window中lib /dll 的关系
13.6.2.生成lib文件
13.6.2.1.填加环境变量
13.6.2.2.生成lib库
13.6.3.建立三方库相关的文件夹
13.6.4.配置当前工程的pro文件
13.6.5.测试环境
13.7.C/C++操作SQLite
13.7.1.连/断
13.7.2.增
13.7.3.删
13.7.4.改
13.7.5.查
14.附录
14.1.ascii码表
14.2.c运算符优先级
14.3.SVN 配置与启动
14.3.1.官方下载地址
14.3.2.创建服务配置文件
14.3.3.配置配置文件
14.3.3.1.svnserve.conf
14.3.3.2.passwd
14.3.3.3.authz
14.3.4.启动服务
14.3.5.创建与删除服务
14.3.5.1.createservice.bat
14.3.5.2.deleteservice.bat
14.3.6.更新与提交
14.4.TestSql
原创作者： 王桂林
技术交流：QQ 329973169
C 语言高级进阶
你懂 c 语言，我不信。
Auth ： 王桂林
Mail ： guilin_wang@163.com
Org ： 能众软件
Web
: http://edu.nzhsoft.cn
1
原创作者： 王桂林
技术交流：QQ 329973169
版本信息：
版本
V1.0
V1.1
修订人
王桂林
王桂林
审阅人
时间
组织
2016.04.02
2016.05.01
能众软件科技有限公司
更多学习：
1
原创作者： 王桂林
技术交流：QQ 329973169
2
原创作者： 王桂林
技术交流：QQ 329973169
1. 数据类型........................................................................................................................................1
1.1. 内存.....................................................................................................................................1
1.2. 补码.....................................................................................................................................1
1.2.1. 运算规则..................................................................................................................1
1.2.2. 补码特点..................................................................................................................1
1.2.3. char(8 位)补码的展示..............................................................................................2
1.3. 数据类型.............................................................................................................................2
1.3.1. 数据类型..................................................................................................................2
1.3.2. 范围计算..................................................................................................................2
1.3.3. 数据类型是对内存的格式化................................................................................. 3
1.4. 类型转化.............................................................................................................................5
1.4.1. 类型转化的原理......................................................................................................5
1.4.2. 隐式转化..................................................................................................................6
1.4.3. 显示(强制类型)转化...............................................................................................7
1.5. 练习.....................................................................................................................................7
1.5.1. 下面的代码输出什么？......................................................................................... 7
1.5.2. 以下程序输出什么？............................................................................................. 7
2. 进程空间........................................................................................................................................9
2.1. 进程空间.............................................................................................................................9
2.2. 进程/程序........................................................................................................................... 9
2.2.1. 程序..........................................................................................................................9
2.2.2. 进程..........................................................................................................................9
2.2.3. 进程到程序..............................................................................................................9
2.3. 数据在进程空间的存储...................................................................................................10
2.3.1. 示意图....................................................................................................................10
2.3.2. 数据在进程空间....................................................................................................11
2.4. 函数的压栈与出栈...........................................................................................................12
2.4.1. 普通函数................................................................................................................12
2.4.2. 递归函数................................................................................................................12
2.5. 课堂实战...........................................................................................................................13
2.5.1. 如下程序中数据存储在哪里............................................................................... 13
2.5.2. 用递归正/逆序打印一个数组..............................................................................14
3. 数组..............................................................................................................................................15
3.1. 一维数组...........................................................................................................................15
3.1.1. 本质........................................................................................................................15
3.1.2. 初始化....................................................................................................................15
3.1.3. 访问........................................................................................................................15
3.1.4. 作参数传递............................................................................................................17
3.1.5. 返回堆中一维数组............................................................................................... 17
3.1.6. 练习........................................................................................................................18
3.2. 二维数组...........................................................................................................................21
3.2.1. 本质........................................................................................................................21
3.2.2. 初始化....................................................................................................................21
1
原创作者： 王桂林
技术交流：QQ 329973169
3.2.3. 访问........................................................................................................................21
3.2.4. 线性存储................................................................................................................23
3.2.5. 作参数传递............................................................................................................24
3.3. 数组指针...........................................................................................................................24
3.3.1. 引入........................................................................................................................24
3.3.2. 定义........................................................................................................................24
3.3.3. 别名........................................................................................................................25
3.3.4. 数组指针与数组名............................................................................................... 25
3.3.5. 应用........................................................................................................................25
3.4. 多维数组...........................................................................................................................26
3.4.1. 本质分析................................................................................................................26
3.4.2. 形像描述................................................................................................................26
3.5. 课堂实战...........................................................................................................................26
3.5.1. 求值?......................................................................................................................26
3.5.2. 下面代码的值为多少？....................................................................................... 27
4. 指针..............................................................................................................................................28
4.1. 内存编址与变量地址.......................................................................................................28
4.1.1. 编址........................................................................................................................28
4.1.2. 变量地址................................................................................................................28
4.2. 指针与指针变量...............................................................................................................29
4.2.1. 指针的本质............................................................................................................29
4.2.2. 指针变量................................................................................................................29
4.2.3. 课堂实战................................................................................................................31
4.3. 二级指针...........................................................................................................................32
4.3.1. 定义与初始化........................................................................................................32
4.3.2. 间接数据访问........................................................................................................33
4.3.3. 初始化一级指针....................................................................................................34
4.3.4. 二级指针的步长....................................................................................................35
4.4. 指针数组(字符指针数组)................................................................................................ 36
4.4.1. 定义........................................................................................................................36
4.4.2. 使用........................................................................................................................36
4.4.3. 二级指针访问指针数组....................................................................................... 37
4.4.4. 常见指针数组........................................................................................................38
4.5. 指针的输入与输出...........................................................................................................39
4.6. 堆上一维空间...................................................................................................................39
4.6.1. 返回值返回(一级指针).........................................................................................39
4.6.2. 参数返回(二级指针).............................................................................................40
4.7. 堆上二维空间...................................................................................................................40
4.7.1. 一级指针作返值输出........................................................................................... 40
4.7.2. 二级指针作返值输出........................................................................................... 41
4.7.3. 三级指针作参数输出........................................................................................... 42
4.7.4. 课堂练习................................................................................................................42
4.8. const 修饰指针.................................................................................................................. 45
4.8.1. const 修饰变量......................................................................................................45
2
原创作者： 王桂林
技术交流：QQ 329973169
4.8.2. const 修饰符..........................................................................................................46
4.8.3. const 修饰指针指向..............................................................................................46
4.8.4. 应用(修饰函数参数).............................................................................................47
4.9. 练习...................................................................................................................................47
4.9.1. 请手写下面代码的输出结果。........................................................................... 47
4.9.2. 天生棋局................................................................................................................48
5. 函数..............................................................................................................................................49
5.1. 函数多参返回...................................................................................................................49
5.1.1. 引列........................................................................................................................49
5.1.2. 正解........................................................................................................................49
5.2. 函数指针...........................................................................................................................49
5.2.1. 函数的本质............................................................................................................49
5.2.2. 函数指针变量定义与赋值................................................................................... 49
5.2.3. 函数指针类型定义............................................................................................... 50
5.2.4. 函数类型别名........................................................................................................50
5.2.5. 函数指针调用........................................................................................................50
5.2.6. 函数指针数组........................................................................................................51
5.3. 回调函数...........................................................................................................................52
5.3.1. 问题引出................................................................................................................52
5.3.2. 回调(函数作参数)................................................................................................. 53
5.3.3. 本质论....................................................................................................................53
5.3.4. qsort........................................................................................................................ 54
5.4. 练习...................................................................................................................................57
5.4.1. (*(void(*) ()) 0)();.....................................................................................................57
6. 再论指针与数组..........................................................................................................................58
6.1. 一级指针与一维数组名...................................................................................................58
6.1.1. 等价条件................................................................................................................58
6.1.2. 便利访问................................................................................................................58
6.2. 二级指针与指针数组名...................................................................................................58
6.2.1. 等价条件................................................................................................................58
6.2.2. 便利访问................................................................................................................58
6.2.3. 通过二级指针申请二维空间............................................................................... 58
6.3. 数组指针与二维数组名...................................................................................................58
6.3.1. 等价条件................................................................................................................58
6.3.2. 便利访问................................................................................................................58
6.4. 关于二级指针与二维数组名.......................................................................................... 58
6.5. 对数组名的引用...............................................................................................................58
6.5.1. 一维数组................................................................................................................58
6.5.2. 二维数组................................................................................................................59
6.6. 小结与练习.......................................................................................................................59
6.6.1. 指针-数组-函数..................................................................................................... 59
6.6.2. 请写出右边的示意............................................................................................... 59
6.6.3. 传参汇总................................................................................................................59
6.6.4. 写出程序的运行结果........................................................................................... 60
3
原创作者： 王桂林
技术交流：QQ 329973169
7. 基于数组排序(提高篇)............................................................................................................... 61
7.1. 选择优化...........................................................................................................................61
7.1.1. 选择原理与步骤....................................................................................................61
7.1.2. 代码实现................................................................................................................61
7.1.3. 优化升级................................................................................................................61
7.2. 冒泡优化...........................................................................................................................62
7.2.1. 冒泡原理与步骤....................................................................................................62
7.2.2. 代码实现................................................................................................................62
7.2.3. 优化升级................................................................................................................62
7.3. 快速排序...........................................................................................................................63
7.3.1. 排序原理与步骤....................................................................................................63
7.3.2. 代码实现................................................................................................................63
7.4. 练习...................................................................................................................................63
7.4.1. 实现二级排序........................................................................................................63
8. 基于数组的查找..........................................................................................................................65
8.1. 线性查找...........................................................................................................................65
8.2. 二分查找...........................................................................................................................65
8.2.1. 原理步骤................................................................................................................65
8.2.2. 迭代版(Iterative)....................................................................................................65
8.2.3. 递归版(Recursive)..................................................................................................65
9. 字符串..........................................................................................................................................67
9.1. 字符串常量.......................................................................................................................67
9.1.1. 定义相关................................................................................................................67
9.1.2. c 语言处理字符串..................................................................................................67
9.2. 字符数组...........................................................................................................................67
9.2.1. 字符数组与字符串............................................................................................... 67
9.2.2. 不等价条件............................................................................................................68
9.2.3. 等价条件................................................................................................................68
9.2.4. N 系列字符串函数.................................................................................................68
9.3. 字符串操作函数...............................................................................................................69
9.3.1. strlen........................................................................................................................69
9.3.2. strcpy/strncpy......................................................................................................... 69
9.3.3. strcat/strncat...........................................................................................................70
9.3.4. strcmp/strncmp.......................................................................................................70
9.3.5. sprintf...................................................................................................................... 70
9.3.6. atoi/itoa...................................................................................................................71
9.3.7. strchr/strrchr...........................................................................................................72
9.3.8. strcspn/strspn..........................................................................................................73
9.3.9. strstr/strpbrk........................................................................................................... 73
9.3.10. strtok..................................................................................................................... 75
9.4. 内存操作函数...................................................................................................................78
9.4.1. memcpy...................................................................................................................78
9.4.2. memmove............................................................................................................... 79
9.4.3. memcmp................................................................................................................. 79
4
原创作者： 王桂林
技术交流：QQ 329973169
9.4.4. memchr................................................................................................................... 80
9.4.5. memset....................................................................................................................80
9.5. 字符串应用案例...............................................................................................................80
9.5.1. trim 系列.................................................................................................................80
9.5.2. 递归逆置字符串....................................................................................................81
9.6. 练习...................................................................................................................................83
9.6.1. 返回 s2 在 s1 中最后一次出现的位置................................................................83
9.6.2. 清空字符串中的制表符....................................................................................... 83
9.6.3. 格式化文件............................................................................................................83
9.6.4. 判断字符串 s1 是否是 s2 循环移位所得............................................................84
9.6.5. 求字符频度............................................................................................................84
9.6.6. 压缩字符串............................................................................................................84
9.6.7. 实现 atoi 功能....................................................................................................... 84
9.6.8. 实现 itoa 功能....................................................................................................... 84
10. 数据结构(双向循环链表)......................................................................................................... 85
10.1. 双向循环链表存在的意义............................................................................................ 85
10.2. 链表构成.........................................................................................................................85
10.2.1. 节点图示..............................................................................................................85
10.2.2. 节点码示..............................................................................................................85
10.2.3. 空链表示意..........................................................................................................86
10.2.4. 非空链表示意......................................................................................................86
10.3. 双向循环链表静态形式................................................................................................ 86
10.3.1. 节点代码..............................................................................................................86
10.3.2. 静态模拟..............................................................................................................86
10.4. 双向循环链表的操作.....................................................................................................86
10.4.1. 创建......................................................................................................................86
10.4.2. 插入......................................................................................................................88
10.4.3. 遍历......................................................................................................................88
10.4.4. 求长度..................................................................................................................89
10.4.5. 查找......................................................................................................................89
10.4.6. 删除节点..............................................................................................................90
10.4.7. 排序......................................................................................................................90
10.4.8. 销毁......................................................................................................................92
10.5. 链表应用-贪吃蛇........................................................................................................... 92
10.5.1. 业务逻辑..............................................................................................................92
10.5.2. MVC 架构分析......................................................................................................92
10.5.3. 其它......................................................................................................................92
10.6. 练习.................................................................................................................................92
10.6.1. 用双向循环链表实现读文件到内存................................................................. 92
11. 动态库与静态库........................................................................................................................93
11.1. 函数库.............................................................................................................................93
11.1.1. 库存在的意义......................................................................................................93
11.1.2. 库的划分..............................................................................................................93
11.1.3. 库的命名规则......................................................................................................93
5
相关推荐
2023年江西萍乡中考道德与法治真题及答案.doc
2012年重庆南川中考生物真题及答案.doc
2013年江西师范大学地理学综合及文艺理论基础考研真题.doc
2020年四川甘孜小升初语文真题及答案I卷.doc
2020年注册岩土工程师专业基础考试真题及答案.doc
2023-2024学年福建省厦门市九年级上学期数学月考试题及答案.doc
2021-2022学年辽宁省沈阳市大东区九年级上学期语文期末试题及答案.doc
2022-2023学年北京东城区初三第一学期物理期末试卷及答案.doc
2018上半年江西教师资格初中地理学科知识与教学能力真题及答案.doc
2012年河北国家公务员申论考试真题及答案-省级.doc
2020-2021学年江苏省扬州市江都区邵樊片九年级上学期数学第一次质量检测试题及答案.doc
2022下半年黑龙江教师资格证中学综合素质真题及答案.doc
