思维导图备注

零基础学C语言第2版
首页 收藏书籍 阅读记录
  • 书签 我的书签
  • 添加书签 添加书签 移除书签 移除书签

第一篇 C语言基础

浏览 2 扫码
  • 小字体
  • 中字体
  • 大字体
2022-01-23 09:21:56
请 登录 再阅读
上一篇:
下一篇:
  • 书签
  • 添加书签 移除书签
  • 前言
  • 第一篇 C语言基础
    • 1.2 如何学好C语言
    • 第2章 跟我写Hello World
      • 2.2 认识LCC-Win32开发环境
        • 2.2.2 启动LCC-Win32
        • 2.2.3 新建Hello World工程
        • 2.2.4 定义新工程
        • 2.2.5 添加源代码到工程
        • 2.2.6 编译器设置
        • 2.2.7 连接器设置
        • 2.2.8 调试器设置
        • 2.2.9 开始编辑代码
      • 2.3 编译运行——欣赏你的杰作
      • 2.4 查看代码如何一步一步被执行——调试排错(debug)
        • 2.4.2 设置断点
        • 2.4.3 调试运行
      • 2.5 小结
      • 2.6 上机实践
    • 1.3 语言概述
      • 1.3.2 什么是机器语言
      • 1.3.3 什么是汇编语言
      • 1.3.4 面向过程的语言
      • 1.3.5 什么是C语言
    • 第3章 分解Hello World——最简单C程序的组成
      • 3.2 为何有必要在代码里留下程序员的解释——注释
      • 3.3 从哪里开始,到哪里结束——main函数
      • 3.4 如何在屏幕上显示文字——函数调用
      • 3.5 编译器如何认识printf函数——#include预处理器指示符
        • 3.5.2 试验寻找#include的作用
        • 3.5.3 #include的作用
      • 3.6 计算1+1——有些小作为的程序
      • 3.7 数据从哪里来,又到哪里去——变量
        • 3.7.2 编译器使用变量符号表
        • 3.7.3 变量及其使用
      • 3.8 自己设计C函数
        • 3.8.2 在main函数中分3次计算3个整数的平均数
        • 3.8.3 自编函数实现计算3个整数的平均数
        • 3.8.4 如何自编写函数
        • 3.8.5 试验观察总结函数声明和函数定义的意义
      • 3.9 语句构成程序
      • 3.10 向好程序员看齐——代码风格
      • 3.11 小结
      • 3.12 上机实践
    • 1.4 深刻认识程序如何开发出来——程序开发周期
      • 1.4.2 编译C源代码
      • 1.4.3 连接目标文件
      • 1.4.4 编译连接过程示例
      • 1.4.5 运行程序
    • 第4章 如何存储和获取数据——变量及数据类型
      • 4.2 计算机中如何表示数据——字节和位
      • 4.3 内存是存储数据的“房间”——认识计算机内存
      • 4.4 数据类型
        • 4.4.2 整数的正负——有符号和无符号
        • 4.4.3 实数类型
        • 4.4.4 字符类型
        • 4.4.5 数据类型总结
      • 4.5 常量
        • 4.5.2 符号常量的优点
        • 4.5.3 字面常量的书写格式
        • 4.5.4 转义字符
        • 4.5.5 字符串
      • 4.6 变量
        • 4.6.2 变量声明的意义
        • 4.6.3 标识符和关键字
        • 4.6.4 变量在内存中占据的空间和变量的值
        • 4.6.5 变量赋初值
      • 4.7 几个与变量相关的经典算法
        • 4.7.2 交换两个变量的值
      • 4.8 小结
      • 4.9 上机实践
    • 1.5 VC++、C++、C和TC——认识开发环境和语言的区别
    • 第5章 用屏幕和键盘交互——简单的输出和输入
      • 5.2 向屏幕输出——printf函数详解
        • 5.2.2 格式字符串的一般形式
        • 5.2.3 %d——十进制形式输出带符号整数
        • 5.2.4 %最小宽度d格式符
        • 5.2.5 %ld格式符——以长整型方式输出
        • 5.2.6 %o格式符——以八进制形式输出整数
        • 5.2.7 %x格式符——以十六进制的形式输出整数
        • 5.2.8 %u格式符——以十进制形式输出unsigned型数据
        • 5.2.9 %c格式符
        • 5.2.10 %s格式符——输出字符串
        • 5.2.11 %f格式符——输出实型数据
        • 5.2.12 %e格式符——以指数形式输出实数
        • 5.2.13 %g格式符——自动选择%f或者%e形式输出
        • 5.2.14 printf函数小结
      • 5.3 字符输出putchar和字符串输出puts
        • 5.3.2 puts函数(字符串输出函数)
      • 5.4 接收键盘输入——scanf函数详解
        • 5.4.2 scanf函数的工作原理
        • 5.4.3 多数据输入分隔规则
        • 5.4.4 格式字符
        • 5.4.5 scanf使用方法说明
        • 5.4.6 使用scanf函数的注意事项
      • 5.5 字符输入函数getchar
      • 5.6 输入输出程序举例
      • 5.7 小结
      • 5.8 上机实践
    • 1.6 小结
    • 第6章 程序的基本构成——运算符和表达式
      • 6.1.2 操作数、运算符和表达式
      • 6.2 算术运算符和算术表达式
        • 6.2.2 ++自增、--自减运算符
        • 6.2.3 算术表达式和运算符的优先级及结合性
      • 6.1.3 C运算符简介
      • 6.3 逗号运算符和逗号表达式
        • 6.3.2 逗号表达式的优先级和结合性
      • 6.4 关系运算符和关系表达式
        • 6.4.2 关系表达式的一般形式
      • 6.5 逻辑运算符和逻辑表达式
        • 6.5.2 逻辑真值表
      • 6.6 赋值运算符和赋值表达式
        • 6.6.2 复合赋值运算符
        • 6.6.3 类型转换
        • 6.6.4 左值与程序实体
      • 6.7 强制类型转换和自动类型转换
        • 6.7.2 自动类型转换
        • 6.7.3 函数调用时的转换
      • 6.8 运算符的优先级
        • 6.8.2 短路表达式
        • 6.8.3 sizeof运算符与sizeof表达式
      • 6.9 小结
      • 6.10 上机实践
    • 1.7 上机实践
    • 第7章 程序的最小独立单元——语句
      • 7.1.2 函数调用语句
      • 7.2 结构化程序设计
        • 7.2.2 算法的表示
        • 7.2.3 算法的伪代码表示
        • 7.2.4 算法的流程图表示
        • 7.2.5 3种控制结构
        • 7.2.6 算法示例
      • 7.1.3 空语句
      • 7.3 小结
      • 7.1.4 复合语句(块语句)
      • 7.4 上机实践
      • 7.1.5 流程控制语句
    • 第8章 条件判断——分支结构
      • 8.1.2 花括号和if结构体
      • 8.2 两条岔路的选择——if else结构
        • 8.2.2 if else结构体
      • 8.3 多分支语句和分支语句嵌套
        • 8.3.2 多分支if结构
        • 8.3.3 分支语句嵌套
      • 8.4 开关语句——switch结构
        • 8.4.2 为什么叫开关语句
        • 8.4.3 default语句
        • 8.4.4 if结构和switch结构之比较
      • 8.5 小结
      • 8.6 上机实践
    • 第9章 一遍又一遍——循环结构
      • 9.1.2 当型循环和直到型循环
      • 9.2 简洁循环语句——while和do while结构
        • 9.2.2 代码块
      • 9.3 最常用的循环语句——for结构
        • 9.3.2 表达式省略
        • 9.3.3 循环终止和步长
      • 9.4 循环嵌套
        • 9.4.2 嵌套的效率
      • 9.5 与循环密切相关的流程转向控制语句
        • 9.5.2 重来一次——continue
        • 9.5.3 随心所欲——goto
      • 9.6 小结
      • 9.7 上机实践
  • 第二篇 一窥C语言门庭
    • 10.1.2 库函数和自定义函数
    • 10.2 自定义函数
      • 10.2.2 函数定义范例
      • 10.2.3 不要重复定义
    • 第11章 同一类型多个元素的集合——简单数组
      • 11.1.2 数组元素的访问
      • 11.2 一维数组
        • 11.2.2 一维数组元素的访问
        • 11.2.3 数组的初始化
        • 11.2.4 不合法的数组操作
      • 11.3 二维数组
        • 11.3.2 二维数组的初始化
        • 11.3.3 二维数组应用举例
      • 11.4 更高维的数组
        • 11.4.2 初始化
        • 11.4.3 多维数组在内存中是如何排列元素的
      • 11.5 小结
      • 11.6 上机实践
    • 10.3 函数调用与返回
      • 10.3.2 传址调用
      • 10.3.3 函数返回
    • 第12章 C语言难点——指针初探
      • 12.1.2 内存中保存的内容
      • 12.2 指针的定义
        • 12.2.2 指针变量的初始化
        • 12.2.3 指针变量的值
        • 12.2.4 取地址操作符&
        • 12.2.5 指针变量占据一定的内存空间
        • 12.2.6 指向指针的指针
      • 12.1.3 地址就是指针
      • 12.3 使用指针
        • 12.3.2 指针的类型和指针所指向的类型
        • 12.3.3 同类型指针的赋值
        • 12.3.4 指针的类型和指针所指向的类型不同
      • 12.4 指针的运算
        • 12.4.2 指针-指针
        • 12.4.3 指针的大小比较
      • 12.5 指针表达式与左值
        • 12.5.2 指针与左值
        • 12.5.3 指针与const
      • 12.6 动态内存分配
        • 12.6.2 malloc与free函数
        • 12.6.3 calloc与free函数
        • 12.6.4 free函数与指针
        • 12.6.5 内存泄漏
        • 12.6.6 释放已经释放了的内存会出问题
      • 12.7 小结
      • 12.8 上机实践
    • 10.4 告诉编译器有这么一个函数——函数原型声明
      • 10.4.2 声明不同于定义
      • 10.4.3 标准库函数的声明
    • 第13章 字符串及字符串操作
      • 13.1.2 C风格字符串在内存中的表示
      • 13.2 字符数组的输入输出
        • 13.2.2 使用gets函数读入整行输入
        • 13.2.3 访问字符数组中某个元素
        • 13.2.4 更便捷的输出——使用puts函数
      • 13.3 字符串处理函数
        • 13.3.2 strlen函数与size_t
        • 13.3.3 字符串复制函数strcpy
        • 13.3.4 字符串比较函数strcmp
        • 13.3.5 字符串连接函数strcat
        • 13.3.6 全转换为大写形式
        • 13.3.7 链式操作
      • 13.4 小结
      • 13.5 上机实践
    • 10.5 面向过程的程序结构
      • 10.5.2 函数的调用过程——模块的配合
      • 10.5.3 一个入口一个出口
      • 10.5.4 自顶向下,逐步求精
      • 10.5.5 封装和可重用
      • 10.5.6 高内聚,低耦合
    • 第14章 结构体、共用体、枚举和typedef
      • 14.1.2 声明结构体变量
      • 14.2 特殊结构体
        • 14.2.2 匿名结构体
      • 14.1.3 初始化结构变量
      • 14.3 共用体
        • 14.3.2 共用体的定义
        • 14.3.3 声明共用体变量
        • 14.3.4 共用体变量的初始化
        • 14.3.5 共用体成员访问
        • 14.3.6 共用体赋值
      • 14.1.4 访问结构体成员
      • 14.4 结构体和共用体的内存差异
        • 14.4.2 结构体变量的内存大小
        • 14.4.3 字节对齐
        • 14.4.4 最宽基本类型
        • 14.4.5 共用体的大小
      • 14.1.5 结构体定义的位置
      • 14.5 枚举类型
        • 14.5.2 声明枚举变量
        • 14.5.3 枚举常量是什么
      • 14.1.6 结构体变量赋值
      • 14.6 给类型取个别名——typedef
        • 14.6.2 #define用法
      • 14.7 小结
      • 14.8 上机实践
    • 10.6 小结
    • 第15章 如何节省内存——位运算
      • 15.1.2 改变状态
      • 15.2 位逻辑运算符
        • 15.2.2 位与运算
        • 15.2.3 位或运算
        • 15.2.4 位异或
        • 15.2.5 实例分析
      • 15.3 移位运算
        • 15.3.2 移位举例
      • 15.4 小结
      • 15.5 上机实践
    • 10.7 上机实践
  • 第三篇 C语言进阶
    • 16.1.2 流
    • 16.2 C语言如何使用文件
      • 16.2.2 文件操作的步骤
    • 第17章 灵活却难以理解——指针进阶
      • 17.1.2 使用数组名常指针表示数组元素
      • 17.2 指针、结构体和结构体数组
        • 17.2.2 声明创建一个结构数组
        • 17.2.3 结构数组的初始化
        • 17.2.4 结构数组的使用
        • 17.2.5 指向结构数组的指针
      • 17.1.3 指向数组元素的指针变量
      • 17.3 函数指针
        • 17.3.2 指向函数的指针
        • 17.3.3 函数指针类型
        • 17.3.4 函数指针做函数参数
        • 17.3.5 函数指针数组
        • 17.3.6 指向函数指针的指针
      • 17.1.4 指向数组的指针变量
      • 17.4 小结
      • 17.1.5 指针数组
      • 17.5 上机实践
    • 16.1.3 重定向
    • 16.3 文件的打开与关闭
      • 16.3.2 打开是否成功
      • 16.3.3 关闭文件——fclose
    • 第18章 更深入的理解——函数进阶
      • 18.1.2 传址调用的副本机制
      • 18.2 函数返回值的副本机制
        • 18.2.2 返回指针申请动态内存
        • 18.2.3 不要返回指向栈内存的指针
        • 18.2.4 返回指向只读存储区的指针
      • 18.3 函数与结构体
        • 18.3.2 结构体变量的成员作为函数参数
        • 18.3.3 返回结构体的函数
        • 18.3.4 返回结构体指针的函数
      • 18.4 函数与数组
        • 18.4.2 数组名作为函数参数
        • 18.4.3 多维数组名作为函数参数
        • 18.4.4 数组名作为函数参数时的退化
      • 18.5 递归
        • 18.5.2 递归两要素
        • 18.5.3 效率与可读性
      • 18.6 带参数的主函数
      • 18.7 小结
      • 18.8 上机实践
    • 16.1.4 文件的处理形式——缓冲区和非缓冲区
    • 16.4 文件的读写
      • 16.4.2 如何判断文件已经结束
      • 16.4.3 字符读写函数——fgetc和fputc
      • 16.4.4 字符串读写函数——fgets和fputs
      • 16.4.5 块读写函数——fread和fwrite
      • 16.4.6 格式化文件输入输出——fprintf与fscanf
    • 第19章 生存期、作用域与可见域
      • 19.1.2 变量的存储类别
      • 19.2 auto变量
        • 19.2.2 作用域和生存期
        • 19.2.3 屏蔽
        • 19.2.4 重复定义
        • 19.2.5 初始化
      • 19.1.3 生存期
      • 19.3 register变量
        • 19.3.2 使用举例
      • 19.1.4 作用域与可见域
      • 19.4 extern变量
        • 19.4.2 全局变量声明
        • 19.4.3 可见域
        • 19.4.4 屏蔽
        • 19.4.5 利与弊
      • 19.5 static变量
        • 19.5.2 静态局部变量
        • 19.5.3 静态全局变量
        • 19.5.4 extern变量和static变量的初始化
      • 19.6 函数的作用域与可见域
        • 19.6.2 外部函数
      • 19.7 结构体定义的作用域与可见域
        • 19.7.2 允许重复定义
      • 19.8 小结
      • 19.9 上机实践
    • 16.1.5 文件的存储形式——文本形式和二进制形式
    • 16.5 文件的定位
      • 16.5.2 得到当前位置——ftell
      • 16.5.3 移动指针——fseek
    • 第20章 编译及预处理
      • 20.1.2 预处理
      • 20.2 程序错误
        • 20.2.2 编译错误
        • 20.2.3 连接错误
        • 20.2.4 逻辑错误
        • 20.2.5 排错
      • 20.1.3 编译
      • 20.3 预处理命令之宏定义
        • 20.3.2 不带参数的宏定义
        • 20.3.3 带参数的宏定义
        • 20.3.4 #define定义常量与const常量
        • 20.3.5 文件包含
        • 20.3.6 条件编译
      • 20.1.4 连接
      • 20.4 小结
      • 20.5 上机实践
    • 16.6 小结
    • 第21章 数据结构
      • 21.1.2 创建链表并遍历输出
      • 21.2 栈和队列
        • 21.2.2 栈的分类
        • 21.2.3 栈的操作
        • 21.2.4 函数与栈
        • 21.2.5 队列
      • 21.1.3 链表的插入
      • 21.3 小结
      • 21.1.4 链表结点的删除
      • 21.4 上机实践
      • 21.1.5 链表的逆置
      • 21.1.6 链表的销毁
      • 21.1.7 综合实例
      • 21.1.8 循环链表
      • 21.1.9 双链表
    • 16.7 上机实践
  • 第四篇 C语言程序设计实例与面试题解析
    • 22.1.2 输入输出样例
    • 22.2 五子棋
      • 22.2.2 输入输出样例
      • 22.2.3 程序分析
      • 22.2.4 主函数程序设计
      • 22.2.5 系统初始化
      • 22.2.6 移动棋子模块
      • 22.2.7 程序胜负判定
      • 22.2.8 小结
    • 第23章 面试题解析
      • 23.1.2 什么是递归
      • 23.2 算法和思维逻辑知识
        • 23.2.2 将16升水平均分给四个人
        • 23.2.3 算出小王买了几瓶啤酒、几瓶饮料
        • 23.2.4 找出不同的苹果
        • 23.2.5 找出不同的球
        • 23.2.6 猜自己的帽子颜色
        • 23.2.7 三筐水果各是什么
        • 23.2.8 最后剩下的是谁
        • 23.2.9 聪明的商人
        • 23.2.10 红球和白球
        • 23.2.11 乌龟赛跑
        • 23.2.12 投硬币
      • 23.1.3 宏定义与操作符的区别
      • 23.1.4 引用与值传递的区别
      • 23.1.5 指针和引用有什么区别
      • 23.1.6 什么是栈
      • 23.1.7 main函数执行前还会执行什么代码
      • 23.1.8 static有什么用途
      • 23.1.9 定义int**a[3][4],则变量占用的内存空间为多少
      • 23.1.10 什么是预编译
      • 23.1.11 int(*s[10])(int)表示什么意义
      • 23.1.12 结构与联合有何区别
    • 22.1.3 程序分析
    • 22.3 扫雷游戏
      • 22.3.2 输入输出样例
      • 22.3.3 程序分析
      • 22.3.4 程序设计
      • 22.3.5 初始化图形设备
      • 22.3.6 事件处理模块
      • 22.3.7 游戏处理部分
      • 22.3.8 小结
    • 22.1.4 程序初始化
    • 22.4 速算24
      • 22.4.2 输入输出样例
      • 22.4.3 程序分析
      • 22.4.4 程序设计
      • 22.4.5 扑克牌处理部分
      • 22.4.6 程序运算部分
      • 22.4.7 小结
    • 22.1.5 初始化图形设备
    • 22.1.6 绘制棋盘
    • 22.1.7 交替绘制黑白棋
    • 22.1.8 游戏(同时判断是否有一方胜利)
    • 22.1.9 小结
  • 附录 ASCII编码表
  • 光盘内容
暂无相关搜索结果!
    展开/收起文章目录

    二维码

    手机扫一扫,轻松掌上学

    《零基础学C语言第2版》电子书下载

    请下载您需要的格式的电子书,随时随地,享受学习的乐趣!
    EPUB 电子书

    书签列表

      阅读记录

      阅读进度: 0.00% ( 0/0 ) 重置阅读进度