顶部
收藏

C语言程序设计:从入门到应用


作者:
主编:石林 程起才 胡超 副主编:周天彤 潘亚平 王军
定价:
46.00 元
版面字数:
450.00千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
暂无
ISBN:
978-7-04-068040-9
物料号:
68040-00
出版时间:
2026-08-24
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

暂无
  • 目录
    • 前辅文
      • 第1章 计算机基础
        • 1.1 计算机系统概述
          • 1.1.1 计算机硬件系统
            • 1.1.2 计算机软件系统
            • 1.2 进制
              • 1.2.1 进制的基本概念
                • 1.2.2 进制之间的转换
                  • 1.2.3 二进制运算
                  • 1.3 编码
                    • 1.3.1 整数编码
                      • 1.3.2 浮点数编码
                        • 1.3.3 字符编码
                        • 1.4 程序设计基础
                          • 1.5 小结
                          • 第2章 C语言编程基础
                            • 2.1 C语言概述与开发环境
                              • 2.1.1 历史与特点
                                • 2.1.2 开发环境
                                • 2.2 C语言源程序的结构
                                  • 2.3 数据类型与变量
                                    • 2.3.1 标识符
                                      • 2.3.2 基本数据类型
                                        • 2.3.3 常量
                                          • 2.3.4 变量
                                          • 2.4 运算符及表达式
                                            • 2.4.1 隐式类型转换
                                              • 2.4.2 算术运算符
                                                • 2.4.3 赋值运算符
                                                  • 2.4.4 关系运算符
                                                    • 2.4.5 逻辑运算符
                                                      • 2.4.6 条件运算符
                                                        • 2.4.7 增1减1运算符
                                                          • 2.4.8 sizeof运算符
                                                            • 2.4.9 位运算符
                                                              • 2.4.10 强制类型转换运算符
                                                                • 2.4.11 逗号运算符
                                                                • 2.5 标准输入输出
                                                                  • 2.5.1 输入输出基本原理
                                                                    • 2.5.2 字符输入输出函数
                                                                      • 2.5.3 格式输入输出函数
                                                                      • 2.6 语句与最简程序结构
                                                                        • 2.7 小结
                                                                          • 编程练习
                                                                          • 第3章 顺序结构
                                                                            • 3.1 顺序结构的流程图表示
                                                                              • 3.2 常用数学函数
                                                                                • 3.3 逐过程调试
                                                                                  • 3.4 应用案例
                                                                                    • 3.5 小结
                                                                                      • 编程练习
                                                                                      • 第4章 选择结构
                                                                                        • 4.1 选择结构的流程图表示
                                                                                          • 4.2 if语句
                                                                                            • 4.2.1 单分支if语句
                                                                                              • 4.2.2 双分支if语句
                                                                                                • 4.2.3 多分支if语句
                                                                                                • 4.3 switch语句
                                                                                                  • 4.4 选择嵌套
                                                                                                    • 4.5 常用字符函数
                                                                                                      • 4.6 应用案例
                                                                                                        • 4.7 小结
                                                                                                          • 编程练习
                                                                                                          • 第5章 循环结构
                                                                                                            • 5.1 循环结构的流程图表示
                                                                                                              • 5.2 while语句
                                                                                                                • 5.3 do-while语句
                                                                                                                  • 5.4 for语句
                                                                                                                    • 5.5 嵌套循环
                                                                                                                      • 5.6 break语句
                                                                                                                        • 5.7 continue语句
                                                                                                                          • 5.8 常用时间日期函数和随机函数
                                                                                                                            • 5.9 应用案例
                                                                                                                              • 5.10 小结
                                                                                                                                • 编程练习
                                                                                                                                • 第6章 函数
                                                                                                                                  • 6.1 函数基本概念
                                                                                                                                    • 6.2 函数定义
                                                                                                                                      • 6.2.1 函数定义的格式
                                                                                                                                        • 6.2.2 return语句
                                                                                                                                        • 6.3 函数调用
                                                                                                                                          • 6.4 函数声明
                                                                                                                                            • 6.5 局部变量和全局变量
                                                                                                                                              • 6.6 递归函数
                                                                                                                                                • 6.7 逐语句调试
                                                                                                                                                  • 6.8 应用案例
                                                                                                                                                    • 6.9 小结
                                                                                                                                                      • 编程练习
                                                                                                                                                      • 第7章 数组
                                                                                                                                                        • 7.1 数组基本概念
                                                                                                                                                          • 7.2 一维数组
                                                                                                                                                            • 7.2.1 一维数组的定义
                                                                                                                                                              • 7.2.2 一维数组的初始化
                                                                                                                                                                • 7.2.3 一维数组的引用
                                                                                                                                                                  • 7.2.4 一维数组与函数参数
                                                                                                                                                                  • 7.3 二维数组
                                                                                                                                                                    • 7.3.1 二维数组的定义
                                                                                                                                                                      • 7.3.2 二维数组的初始化
                                                                                                                                                                        • 7.3.3 二维数组的引用
                                                                                                                                                                          • 7.3.4 二维数组与函数参数
                                                                                                                                                                          • 7.4 字符数组与字符串
                                                                                                                                                                            • 7.4.1 字符数组的定义与初始化
                                                                                                                                                                              • 7.4.2 字符数组的输入与输出
                                                                                                                                                                                • 7.4.3 字符数组与函数参数
                                                                                                                                                                                  • 7.4.4 常用字符串处理函数
                                                                                                                                                                                  • 7.5 应用案例
                                                                                                                                                                                    • 7.6 小结
                                                                                                                                                                                      • 编程练习
                                                                                                                                                                                      • 第8章 指针
                                                                                                                                                                                        • 8.1 指针概念
                                                                                                                                                                                          • 8.1.1 指针的定义与初始化
                                                                                                                                                                                            • 8.1.2 指针的引用
                                                                                                                                                                                              • 8.1.3 指针作为函数参数
                                                                                                                                                                                              • 8.2 数组和指针
                                                                                                                                                                                                • 8.2.1 指向数组元素的指针
                                                                                                                                                                                                  • 8.2.2 指向数组的指针
                                                                                                                                                                                                    • 8.2.3 数组名作为函数参数
                                                                                                                                                                                                      • 8.2.4 字符指针与字符串
                                                                                                                                                                                                      • 8.3 指针数组与多级指针
                                                                                                                                                                                                        • 8.3.1 指针数组
                                                                                                                                                                                                          • 8.3.2 指向指针的指针
                                                                                                                                                                                                          • 8.4 函数与指针
                                                                                                                                                                                                            • 8.4.1 指向函数的指针
                                                                                                                                                                                                              • 8.4.2 返回指针的函数
                                                                                                                                                                                                              • 8.5 带参数的main函数
                                                                                                                                                                                                                • 8.6 应用案例
                                                                                                                                                                                                                  • 8.7 小结
                                                                                                                                                                                                                    • 编程练习
                                                                                                                                                                                                                    • 第9章 用户自定义类型
                                                                                                                                                                                                                      • 9.1 结构体类型
                                                                                                                                                                                                                        • 9.1.1 结构体类型声明
                                                                                                                                                                                                                          • 9.1.2 结构体变量
                                                                                                                                                                                                                            • 9.1.3 指向结构体变量的指针
                                                                                                                                                                                                                              • 9.1.4 结构体变量与函数
                                                                                                                                                                                                                                • 9.1.5 结构体数组
                                                                                                                                                                                                                                • 9.2 共用体类型
                                                                                                                                                                                                                                  • 9.3 枚举类型
                                                                                                                                                                                                                                    • 9.4 类型别名
                                                                                                                                                                                                                                      • 9.5 位段
                                                                                                                                                                                                                                        • 9.6 应用案例
                                                                                                                                                                                                                                          • 9.7 小结
                                                                                                                                                                                                                                            • 编程练习
                                                                                                                                                                                                                                            • 第10章 动态内存分配与链表
                                                                                                                                                                                                                                              • 10.1 内存管理
                                                                                                                                                                                                                                                • 10.1.1 内存分布
                                                                                                                                                                                                                                                  • 10.1.2 动态内存分配与释放函数
                                                                                                                                                                                                                                                  • 10.2 链表基本操作
                                                                                                                                                                                                                                                    • 10.2.1 链表的基本概念
                                                                                                                                                                                                                                                      • 10.2.2 链表的创建
                                                                                                                                                                                                                                                        • 10.2.3 链表的输出
                                                                                                                                                                                                                                                          • 10.2.4 链表的查找
                                                                                                                                                                                                                                                            • 10.2.5 链表的插入
                                                                                                                                                                                                                                                              • 10.2.6 链表的删除
                                                                                                                                                                                                                                                              • 10.3 应用案例
                                                                                                                                                                                                                                                                • 10.4 小结
                                                                                                                                                                                                                                                                  • 编程练习
                                                                                                                                                                                                                                                                  • 第11章 文件输入输出
                                                                                                                                                                                                                                                                    • 11.1 文件的基本概念
                                                                                                                                                                                                                                                                      • 11.1.1 文件路径及分类
                                                                                                                                                                                                                                                                        • 11.1.2 文件流与文件指针
                                                                                                                                                                                                                                                                        • 11.2 文件基本操作流程
                                                                                                                                                                                                                                                                          • 11.2.1 打开文件
                                                                                                                                                                                                                                                                            • 11.2.2 读写文件
                                                                                                                                                                                                                                                                              • 11.2.3 关闭文件
                                                                                                                                                                                                                                                                              • 11.3 文件定位
                                                                                                                                                                                                                                                                                • 11.4 文件末尾与错误检测
                                                                                                                                                                                                                                                                                  • 11.5 应用案例
                                                                                                                                                                                                                                                                                    • 11.6 小结
                                                                                                                                                                                                                                                                                      • 编程练习
                                                                                                                                                                                                                                                                                      • 第12章 预处理命令
                                                                                                                                                                                                                                                                                        • 12.1 宏定义
                                                                                                                                                                                                                                                                                          • 12.2 文件包含
                                                                                                                                                                                                                                                                                            • 12.3 条件编译
                                                                                                                                                                                                                                                                                              • 12.4 小结
                                                                                                                                                                                                                                                                                              • 第13章 多文件程序
                                                                                                                                                                                                                                                                                                • 13.1 多文件程序的基本概念
                                                                                                                                                                                                                                                                                                  • 13.2 模块间通信
                                                                                                                                                                                                                                                                                                    • 13.2.1 跨文件函数调用
                                                                                                                                                                                                                                                                                                      • 13.2.2 全局变量共享
                                                                                                                                                                                                                                                                                                        • 13.2.3 限制模块内部访问
                                                                                                                                                                                                                                                                                                          • 13.2.4 头文件的模块化设计原则
                                                                                                                                                                                                                                                                                                          • 13.3 应用案例
                                                                                                                                                                                                                                                                                                            • 13.4 小结
                                                                                                                                                                                                                                                                                                              • 编程练习
                                                                                                                                                                                                                                                                                                              • 第14章 综合项目开发——贪吃蛇游戏
                                                                                                                                                                                                                                                                                                                • 14.1 项目概述
                                                                                                                                                                                                                                                                                                                  • 14.2 需求分析
                                                                                                                                                                                                                                                                                                                    • 14.2.1 功能需求
                                                                                                                                                                                                                                                                                                                      • 14.2.2 环境需求
                                                                                                                                                                                                                                                                                                                      • 14.3 总体设计
                                                                                                                                                                                                                                                                                                                        • 14.3.1 模块结构图
                                                                                                                                                                                                                                                                                                                          • 14.3.2 函数调用关系
                                                                                                                                                                                                                                                                                                                            • 14.3.3 数据结构设计
                                                                                                                                                                                                                                                                                                                            • 14.4 详细设计
                                                                                                                                                                                                                                                                                                                              • 14.4.1 UI模块
                                                                                                                                                                                                                                                                                                                                • 14.4.2 Core模块
                                                                                                                                                                                                                                                                                                                                  • 14.4.3 Store模块
                                                                                                                                                                                                                                                                                                                                  • 14.5 代码实现
                                                                                                                                                                                                                                                                                                                                    • 14.5.1 代码目录结构
                                                                                                                                                                                                                                                                                                                                      • 14.5.2 头文件代码
                                                                                                                                                                                                                                                                                                                                        • 14.5.3 源文件代码
                                                                                                                                                                                                                                                                                                                                        • 14.6 测试运行
                                                                                                                                                                                                                                                                                                                                        • 参考文献
                                                                                                                                                                                                                                                                                                                                          • 附录1 标准ASCII字符集对照表
                                                                                                                                                                                                                                                                                                                                            • 附录2 运算符优先级和结合性

                                                                                                                                                                                                                                                                                                                                            相关图书