顶部
收藏

计算机语言与程序设计:以C语言为例


作者:
主编:硕良勋;副主编:王楠、赵占芳、王俊跃
定价:
49.00 元
版面字数:
420.00千字
开本:
16开
装帧形式:
平装
页数:
296
最新
印次时间:
2026年08月
ISBN:
978-7-04-068262-5
物料号:
68262-00
出版时间:
2026-08-28
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

本书以C语言为例,介绍了计算机语言与程序设计的基本知识及方法。本书共分14章,主要内容包括从语言到软件、C语言概述、基本符号与量、表达式、语句、流程控制、函数、数组、自定义类型、指针、文件、多文件程序、程序设计方法论,以及综合实例。本书内容丰富、体系完善,并以扫雷游戏的完整实现作为贯穿全书的实践项目。通过本书的学习,学习者可以掌握C语言的基本知识和程序设计方法,并在此基础上逐步形成较为系统的计算机语言认知框架,为后续专业课程学习和程序设计实践奠定基础。 本书可作为高等学校计算机及相关专业程序设计课程的教材,也可作为程序设计初学者的参考读物。
  • 目录
    • 前辅文
      • 第1章 从语言到软件
        • 1.1 语言
          • 1.1.1 语言的本质
            • 1.1.2 语言的基本组成
              • 1.1.3 语言的认知学习路径
              • 1.2 写作
                • 1.2.1 采集阶段
                  • 1.2.2 构思阶段
                    • 1.2.3 表述阶段
                    • 1.3 计算机语言
                      • 1.3.1 程序设计
                        • 1.3.2 理解程序的三个维度
                        • 本章小结
                          • 思维升华
                            • 习题
                            • 第2章 C语言概述
                              • 2.1 为什么从C语言开始
                                • 2.1.1 高级语言中的“中级语言”
                                  • 2.1.2 C语言是众多现代程序设计语言的基石
                                    • 2.1.3 C语言体现了计算机思维的基本要求
                                      • 2.1.4 C语言的标准沿革
                                      • 2.2 C语言的构成体系
                                        • 2.2.1 从人类语言到C语言的思维迁移
                                          • 2.2.2 结构层次对照
                                          • 2.3 C程序的基本结构
                                            • 2.3.1 第一个C程序
                                              • 2.3.2 深入理解各组成部分
                                                • 2.3.3 从源代码到可执行程序
                                                  • 2.3.4 从第一个程序开始修改
                                                    • 2.3.5 程序不仅要能运行,还要便于阅读
                                                    • 2.4 C语言的学习路径与扫雷游戏
                                                      • 2.4.1 循序渐进的学习路线
                                                        • 2.4.2 贯穿始终的实践项目
                                                          • 2.4.3 给初学者的学习建议
                                                          • 本章小结
                                                            • 思维升华
                                                              • 习题
                                                              • 第3章 基本符号与量
                                                                • 3.1 C语言的符号体系
                                                                  • 3.1.1 关键字
                                                                    • 3.1.2 标识符
                                                                      • 3.1.3 运算符
                                                                        • 3.1.4 分隔符
                                                                        • 3.2 基本数据类型
                                                                          • 3.2.1 整型数据
                                                                            • 3.2.2 浮点型数据
                                                                              • 3.2.3 字符型数据
                                                                                • 3.2.4 布尔型数据
                                                                                • 3.3 程序中的量
                                                                                  • 3.3.1 字面常量
                                                                                    • 3.3.2 符号常量
                                                                                      • 3.3.3 变量
                                                                                      • 本章小结
                                                                                        • 思维升华
                                                                                          • 习题
                                                                                          • 第4章 表达式
                                                                                            • 4.1 表达式的本质与分类
                                                                                              • 4.1.1 表达式的核心特征
                                                                                                • 4.1.2 表达式的分类体系
                                                                                                  • 4.1.3 运算符的运算法则
                                                                                                  • 4.2 算术运算符
                                                                                                    • 4.2.1 算术运算符解析
                                                                                                      • 4.2.2 算术运算中的溢出问题
                                                                                                        • 4.2.3 算术运算的类型转换
                                                                                                        • 4.3 类型转换运算符
                                                                                                          • 4.4 sizeof运算符
                                                                                                            • 4.5 关系与逻辑运算符
                                                                                                              • 4.5.1 关系运算符和表达式
                                                                                                                • 4.5.2 逻辑运算符和表达式
                                                                                                                  • 4.5.3 关系和逻辑表达式的常见错误
                                                                                                                  • 4.6 赋值运算符
                                                                                                                    • 4.6.1 简单赋值
                                                                                                                      • 4.6.2 赋值与类型转换
                                                                                                                        • 4.6.3 复合赋值
                                                                                                                        • 4.7 自增和自减运算符
                                                                                                                          • 4.8 条件运算符
                                                                                                                            • 4.9 逗号运算符
                                                                                                                              • 4.10 位运算符
                                                                                                                                • 本章小结
                                                                                                                                  • 思维升华
                                                                                                                                    • 习题
                                                                                                                                    • 第5章 语句
                                                                                                                                      • 5.1 语句的分类
                                                                                                                                        • 5.1.1 简单语句
                                                                                                                                          • 5.1.2 复合语句
                                                                                                                                          • 5.2 库函数和函数调用语句
                                                                                                                                            • 5.2.1 输入输出库函数
                                                                                                                                              • 5.2.2 数学计算库函数
                                                                                                                                                • 5.2.3 随机数库函数
                                                                                                                                                • 本章小结
                                                                                                                                                  • 思维升华
                                                                                                                                                    • 习题
                                                                                                                                                    • 第6章 流程控制
                                                                                                                                                      • 6.1 顺序结构
                                                                                                                                                        • 6.2 选择结构
                                                                                                                                                          • 6.2.1 if语句
                                                                                                                                                            • 6.2.2 switch语句
                                                                                                                                                            • 6.3 循环结构
                                                                                                                                                              • 6.3.1 for循环:计数控制
                                                                                                                                                                • 6.3.2 while循环:条件控制的重复
                                                                                                                                                                  • 6.3.3 do-while循环:至少执行一次
                                                                                                                                                                    • 6.3.4 嵌套循环:循环中的循环
                                                                                                                                                                    • 6.4 跳转语句:break、continue、goto
                                                                                                                                                                      • 6.4.1 break语句:提前退出
                                                                                                                                                                        • 6.4.2 continue语句:跳过本次循环
                                                                                                                                                                          • 6.4.3 goto语句:有争议的跳转
                                                                                                                                                                          • 本章小结
                                                                                                                                                                            • 思维升华
                                                                                                                                                                              • 习题
                                                                                                                                                                              • 第7章 函数
                                                                                                                                                                                • 7.1 函数的本质与价值
                                                                                                                                                                                  • 7.1.1 函数的概念
                                                                                                                                                                                    • 7.1.2 引入函数的意义
                                                                                                                                                                                    • 7.2 函数的定义与调用
                                                                                                                                                                                      • 7.2.1 函数定义的基本结构
                                                                                                                                                                                        • 7.2.2 函数调用
                                                                                                                                                                                        • 7.3 参数传递与返回值
                                                                                                                                                                                          • 7.3.1 参数传递机制
                                                                                                                                                                                            • 7.3.2 返回值机制
                                                                                                                                                                                              • 7.3.3 函数原型
                                                                                                                                                                                              • 7.4 变量的作用域与存储期
                                                                                                                                                                                                • 7.4.1 作用域
                                                                                                                                                                                                  • 7.4.2 存储期
                                                                                                                                                                                                  • 7.5 递归
                                                                                                                                                                                                    • 7.5.1 递归的基本原理
                                                                                                                                                                                                      • 7.5.2 递归优化
                                                                                                                                                                                                      • 7.6 模块化设计原则
                                                                                                                                                                                                        • 7.6.1 高内聚低耦合
                                                                                                                                                                                                          • 7.6.2 接口设计与约定
                                                                                                                                                                                                          • 本章小结
                                                                                                                                                                                                            • 思维升华
                                                                                                                                                                                                              • 习题
                                                                                                                                                                                                              • 第8章 数组
                                                                                                                                                                                                                • 8.1 数组的本质:连续内存的抽象
                                                                                                                                                                                                                  • 8.1.1 从单个变量到数组的思维跃迁
                                                                                                                                                                                                                    • 8.1.2 数组的物理本质
                                                                                                                                                                                                                    • 8.2 一维数组
                                                                                                                                                                                                                      • 8.2.1 一维数组的定义
                                                                                                                                                                                                                        • 8.2.2 一维数组的初始化
                                                                                                                                                                                                                          • 8.2.3 一维数组元素的访问
                                                                                                                                                                                                                            • 8.2.4 一维数组的基本操作
                                                                                                                                                                                                                            • 8.3 二维数组
                                                                                                                                                                                                                              • 8.3.1 二维数组的定义
                                                                                                                                                                                                                                • 8.3.2 二维数组的初始化
                                                                                                                                                                                                                                  • 8.3.3 二维数组的遍历
                                                                                                                                                                                                                                  • 8.4 字符数组与字符串
                                                                                                                                                                                                                                    • 8.4.1 字符数组的定义与初始化
                                                                                                                                                                                                                                      • 8.4.2 字符串输入输出
                                                                                                                                                                                                                                        • 8.4.3 字符串处理函数
                                                                                                                                                                                                                                        • 8.5 数组作为函数参数
                                                                                                                                                                                                                                          • 8.5.1 一维数组作为函数参数
                                                                                                                                                                                                                                            • 8.5.2 二维数组作为函数参数
                                                                                                                                                                                                                                              • 8.5.3 数组参数的const限定
                                                                                                                                                                                                                                              • 本章小结
                                                                                                                                                                                                                                                • 思维升华
                                                                                                                                                                                                                                                  • 习题
                                                                                                                                                                                                                                                  • 第9章 自定义类型
                                                                                                                                                                                                                                                    • 9.1 结构体
                                                                                                                                                                                                                                                      • 9.1.1 结构体类型声明
                                                                                                                                                                                                                                                        • 9.1.2 结构体变量的定义和初始化
                                                                                                                                                                                                                                                          • 9.1.3 结构体变量的赋值与引用
                                                                                                                                                                                                                                                            • 9.1.4 使用typedef简化类型名
                                                                                                                                                                                                                                                              • 9.1.5 结构体的内存布局与对齐
                                                                                                                                                                                                                                                                • 9.1.6 结构体作为函数参数
                                                                                                                                                                                                                                                                  • 9.1.7 结构体作为返回值
                                                                                                                                                                                                                                                                    • 9.1.8 结构体数组
                                                                                                                                                                                                                                                                    • 9.2 联合体
                                                                                                                                                                                                                                                                      • 9.2.1 联合体的定义与初始化
                                                                                                                                                                                                                                                                        • 9.2.2 联合体的典型应用
                                                                                                                                                                                                                                                                        • 9.3 枚举
                                                                                                                                                                                                                                                                          • 9.3.1 枚举类型的定义
                                                                                                                                                                                                                                                                            • 9.3.2 枚举变量
                                                                                                                                                                                                                                                                              • 9.3.3 枚举的输入输出
                                                                                                                                                                                                                                                                              • 本章小结
                                                                                                                                                                                                                                                                                • 思维升华
                                                                                                                                                                                                                                                                                  • 习题
                                                                                                                                                                                                                                                                                  • 第10章 指针
                                                                                                                                                                                                                                                                                    • 10.1 指针的概念与操作
                                                                                                                                                                                                                                                                                      • 10.1.1 指针变量的定义
                                                                                                                                                                                                                                                                                        • 10.1.2 指针的初始化
                                                                                                                                                                                                                                                                                          • 10.1.3 const修饰的指针
                                                                                                                                                                                                                                                                                            • 10.1.4 void指针与多级指针
                                                                                                                                                                                                                                                                                            • 10.2 指针与数组
                                                                                                                                                                                                                                                                                              • 10.2.1 下标运算的指针等价性
                                                                                                                                                                                                                                                                                                • 10.2.2 数组指针
                                                                                                                                                                                                                                                                                                  • 10.2.3 指针数组
                                                                                                                                                                                                                                                                                                  • 10.3 指针与函数
                                                                                                                                                                                                                                                                                                    • 10.3.1 指针作为函数参数
                                                                                                                                                                                                                                                                                                      • 10.3.2 指针作为函数返回值
                                                                                                                                                                                                                                                                                                        • 10.3.3 函数指针
                                                                                                                                                                                                                                                                                                        • 10.4 动态内存管理
                                                                                                                                                                                                                                                                                                          • 10.4.1 堆与栈
                                                                                                                                                                                                                                                                                                            • 10.4.2 malloc、calloc、realloc和free函数
                                                                                                                                                                                                                                                                                                              • 10.4.3 动态数组
                                                                                                                                                                                                                                                                                                              • 10.5 自引用结构与链表
                                                                                                                                                                                                                                                                                                                • 10.5.1 链表结构概述
                                                                                                                                                                                                                                                                                                                  • 10.5.2 结点结构
                                                                                                                                                                                                                                                                                                                    • 10.5.3 链表的基本操作
                                                                                                                                                                                                                                                                                                                    • 本章小结
                                                                                                                                                                                                                                                                                                                      • 思维升华
                                                                                                                                                                                                                                                                                                                        • 习题
                                                                                                                                                                                                                                                                                                                        • 第11章 文件
                                                                                                                                                                                                                                                                                                                          • 11.1 文件的基本概念
                                                                                                                                                                                                                                                                                                                            • 11.1.1 什么是文件?
                                                                                                                                                                                                                                                                                                                              • 11.1.2 文件指针
                                                                                                                                                                                                                                                                                                                              • 11.2 文件的打开与关闭
                                                                                                                                                                                                                                                                                                                                • 11.2.1 fopen函数
                                                                                                                                                                                                                                                                                                                                  • 11.2.2 fclose函数
                                                                                                                                                                                                                                                                                                                                    • 11.2.3 标准流
                                                                                                                                                                                                                                                                                                                                    • 11.3 文件的读写操作
                                                                                                                                                                                                                                                                                                                                      • 11.3.1 字符读写
                                                                                                                                                                                                                                                                                                                                        • 11.3.2 字符串读写
                                                                                                                                                                                                                                                                                                                                          • 11.3.3 格式化读写
                                                                                                                                                                                                                                                                                                                                            • 11.3.4 块读写
                                                                                                                                                                                                                                                                                                                                              • 11.3.5 文件结束与错误检测
                                                                                                                                                                                                                                                                                                                                              • 11.4 随机访问文件
                                                                                                                                                                                                                                                                                                                                                • 11.5 文本文件与二进制文件的深入比较
                                                                                                                                                                                                                                                                                                                                                  • 11.6 缓冲区与刷新
                                                                                                                                                                                                                                                                                                                                                    • 11.6.1 缓冲区
                                                                                                                                                                                                                                                                                                                                                      • 11.6.2 刷新缓冲区
                                                                                                                                                                                                                                                                                                                                                      • 11.7 扫雷游戏记录的保存与读取
                                                                                                                                                                                                                                                                                                                                                        • 11.7.1 游戏进度保存与加载
                                                                                                                                                                                                                                                                                                                                                          • 11.7.2 最高分记录系统
                                                                                                                                                                                                                                                                                                                                                          • 本章小结
                                                                                                                                                                                                                                                                                                                                                            • 思维升华
                                                                                                                                                                                                                                                                                                                                                              • 习题
                                                                                                                                                                                                                                                                                                                                                              • 第12章 多文件程序
                                                                                                                                                                                                                                                                                                                                                                • 12.1 多文件组织
                                                                                                                                                                                                                                                                                                                                                                  • 12.1.1 单文件程序的局限性
                                                                                                                                                                                                                                                                                                                                                                    • 12.1.2 多文件组织的优势
                                                                                                                                                                                                                                                                                                                                                                      • 12.1.3 多文件程序的组织方式
                                                                                                                                                                                                                                                                                                                                                                        • 12.1.4 程序的编译与连接
                                                                                                                                                                                                                                                                                                                                                                          • 12.1.5 常见的编译错误与连接错误
                                                                                                                                                                                                                                                                                                                                                                          • 12.2 预处理指令
                                                                                                                                                                                                                                                                                                                                                                            • 12.2.1 文件包含
                                                                                                                                                                                                                                                                                                                                                                              • 12.2.2 宏定义
                                                                                                                                                                                                                                                                                                                                                                                • 12.2.3 宏技巧
                                                                                                                                                                                                                                                                                                                                                                                  • 12.2.4 条件编译
                                                                                                                                                                                                                                                                                                                                                                                  • 12.3 多文件系统的设计
                                                                                                                                                                                                                                                                                                                                                                                    • 12.3.1 头文件的设计原则
                                                                                                                                                                                                                                                                                                                                                                                      • 12.3.2 连接属性与存储类
                                                                                                                                                                                                                                                                                                                                                                                      • 12.4 大型项目的管理
                                                                                                                                                                                                                                                                                                                                                                                        • 12.4.1 模块化设计模式
                                                                                                                                                                                                                                                                                                                                                                                          • 12.4.2 版本控制与协作
                                                                                                                                                                                                                                                                                                                                                                                          • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                            • 思维升华
                                                                                                                                                                                                                                                                                                                                                                                              • 习题
                                                                                                                                                                                                                                                                                                                                                                                              • 第13章 程序设计方法论
                                                                                                                                                                                                                                                                                                                                                                                                • 13.1 问题分析与算法设计
                                                                                                                                                                                                                                                                                                                                                                                                  • 13.1.1 系统化问题分析方法
                                                                                                                                                                                                                                                                                                                                                                                                    • 13.1.2 算法设计策略与复杂度分析
                                                                                                                                                                                                                                                                                                                                                                                                    • 13.2 数据结构的选择
                                                                                                                                                                                                                                                                                                                                                                                                      • 13.3 模块化与接口设计
                                                                                                                                                                                                                                                                                                                                                                                                        • 13.3.1 接口设计原则
                                                                                                                                                                                                                                                                                                                                                                                                          • 13.3.2 设计模式应用
                                                                                                                                                                                                                                                                                                                                                                                                          • 13.4 代码重构与性能优化
                                                                                                                                                                                                                                                                                                                                                                                                            • 13.4.1 代码重构
                                                                                                                                                                                                                                                                                                                                                                                                              • 13.4.2 性能优化
                                                                                                                                                                                                                                                                                                                                                                                                              • 13.5 测试方法与调试策略
                                                                                                                                                                                                                                                                                                                                                                                                                • 13.5.1 测试方法与测试驱动开发
                                                                                                                                                                                                                                                                                                                                                                                                                  • 13.5.2 系统化调试策略
                                                                                                                                                                                                                                                                                                                                                                                                                  • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                    • 思维升华
                                                                                                                                                                                                                                                                                                                                                                                                                      • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                      • 第14章 综合实例:扫雷游戏的完整实现
                                                                                                                                                                                                                                                                                                                                                                                                                        • 14.1 需求分析与架构设计
                                                                                                                                                                                                                                                                                                                                                                                                                          • 14.1.1 功能性需求
                                                                                                                                                                                                                                                                                                                                                                                                                            • 14.1.2 非功能性需求
                                                                                                                                                                                                                                                                                                                                                                                                                              • 14.1.3 架构设计
                                                                                                                                                                                                                                                                                                                                                                                                                              • 14.2 功能模块实现
                                                                                                                                                                                                                                                                                                                                                                                                                                • 14.2.1 游戏逻辑模块
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 14.2.2 用户界面模块
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 14.2.3 主程序
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 14.3 模块集成与编译运行
                                                                                                                                                                                                                                                                                                                                                                                                                                      • 14.4 性能优化与测试
                                                                                                                                                                                                                                                                                                                                                                                                                                        • 14.4.1 性能优化
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 14.4.2 测试策略
                                                                                                                                                                                                                                                                                                                                                                                                                                          • 14.5 撰写相关文档
                                                                                                                                                                                                                                                                                                                                                                                                                                            • 14.5.1 README文件(必做)
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 14.5.2 代码注释(建议)
                                                                                                                                                                                                                                                                                                                                                                                                                                                • 14.5.3 用户手册(推荐)
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 14.5.4 开发文档(扩展)
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 14.5.5 测试文档(建议)
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 本章小结
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 思维升华
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 习题
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 参考文献
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 附录A C语言的核心关键字
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 附录B 运算符的优先级与结合性
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 附录C 标准ASCII码表与字符处理提示
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 附录D 常用的标准库函数
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 附录E 常见的程序错误及解决方法
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 附录F C语言编程规范与风格指南
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 后记:开启一场与计算机的深度对话

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      相关图书