顶部
收藏

C程序设计精编


作者:
肖阳春等
定价:
33.30 元
版面字数:
290.00千字
开本:
16开
装帧形式:
平装
页数:
220
最新
印次时间:
2026年1月
ISBN:
978-7-04-052120-7
物料号:
52120-00
出版时间:
2019年9月
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

本书作为C语言程序设计课程的教材,共由9章组成。其主要内容包括:C程序设计基础、分支结构、循环结构、函数、数组、指针、结构体、文件、综合案例。每章后面都有实验内容及指导,并配有一定数量的习题。全书以案例进行知识点的讲解,内容安排紧凑、简明扼要、由浅入深,尤其适用于学时少、内容不减的教学,一本教材涵盖了理论教学、实验教学和课后练习三方面的内容,为教与学提供了极大的方便。

本书可作为本科院校非计算机专业本科生、研究生的相关课程教材,也可作为计算机专业学生学习C语言程序设计的教材,同时还可作为自学者参考用书。

  • 目录
    • 前辅文
      • 第1章 C程序设计基础
        • 1.1 简单C程序的编写
          • 1.1.1 案例
            • 1.1.2 数据类型、常量与变量
              • 1.1.3 运算符、表达式和语句
                • 1.1.4 格式化输出函数printf( )
                  • 1.1.5 C程序的编写与执行
                  • 1.2 求任意半径的圆面积
                    • 1.2.1 案例
                      • 1.2.2 格式化输入函数scanf( )
                        • 1.2.3 C程序的函数
                        • 1.3 实验内容及指导
                          • 习题1
                          • 第2章 分支结构
                            • 2.1 判断闰年
                              • 2.1.1 案例
                                • 2.1.2 if-else语句
                                • 2.2 判断字母、数字和其他字符
                                  • 2.2.1 案例
                                    • 2.2.2 else-if语句
                                      • 2.2.3 字符输入函数getchar( )
                                      • 2.3 选择执行菜单项
                                        • 2.3.1 案例
                                          • 2.3.2 switch语句
                                          • 2.4 实验内容及指导
                                            • 习题2
                                            • 第3章 循环结构
                                              • 3.1 求和问题
                                                • 3.1.1 案例
                                                  • 3.1.2 while语句
                                                  • 3.2 求π值
                                                    • 3.2.1 案例
                                                      • 3.2.2 do-while语句
                                                      • 3.3 素数问题
                                                        • 3.3.1 案例
                                                          • 3.3.2 for语句
                                                          • 3.4 输出图形
                                                            • 3.4.1 金字塔
                                                              • 3.4.2 九九乘法表
                                                              • 3.5 实验内容及指导
                                                                • 习题3
                                                                • 第4章 函数
                                                                  • 4.1 人民币兑换问题
                                                                    • 4.1.1 案例
                                                                      • 4.1.2 函数的定义
                                                                        • 4.1.3 无参函数的调用
                                                                          • 4.1.4 函数的返回值
                                                                          • 4.2 三角形问题
                                                                            • 4.2.1 案例
                                                                              • 4.2.2 函数调用的一般形式
                                                                                • 4.2.3 函数原型
                                                                                  • 4.2.4 变量作为形参
                                                                                  • 4.3 二分法求方程的根
                                                                                    • 4.3.1 案例
                                                                                      • 4.3.2 局部变量与全局变量
                                                                                        • 4.3.3 变量的存储类型
                                                                                        • 4.4 实验内容及指导
                                                                                          • 习题4
                                                                                          • 第5章 数组
                                                                                            • 5.1 日期转换
                                                                                              • 5.1.1 案例
                                                                                                • 5.1.2 一维数组的定义
                                                                                                  • 5.1.3 一维数组的初始化
                                                                                                  • 5.2 找最大数
                                                                                                    • 5.2.1 案例
                                                                                                      • 5.2.2 数组元素的引用
                                                                                                        • 5.2.3 一维数组名作为函数的参数
                                                                                                        • 5.3 一维数组名作为函数的参数案例
                                                                                                          • 5.3.1 冒泡排序
                                                                                                            • 5.3.2 字符串比较
                                                                                                            • 5.4 判断回文
                                                                                                              • 5.4.1 案例
                                                                                                                • 5.4.2 字符串输入函数gets( )
                                                                                                                  • 5.4.3 字符串输出函数puts( )
                                                                                                                  • 5.5 字符后移
                                                                                                                    • 5.5.1 案例
                                                                                                                      • 5.5.2 常用字符串处理函数
                                                                                                                      • 5.6 矩阵运算
                                                                                                                        • 5.6.1 案例
                                                                                                                          • 5.6.2 二维数组
                                                                                                                            • 5.6.3 二维数组名作为函数的参数
                                                                                                                            • 5.7 实验内容及指导
                                                                                                                              • 习题5
                                                                                                                              • 第6章 指针
                                                                                                                                • 6.1 两个变量值的交换
                                                                                                                                  • 6.1.1 案例
                                                                                                                                    • 6.1.2 指针与地址
                                                                                                                                      • 6.1.3 指针变量的定义
                                                                                                                                        • 6.1.4 地址运算符
                                                                                                                                          • 6.1.5 函数的传址调用
                                                                                                                                          • 6.2 统计一个英文句子的字符数
                                                                                                                                            • 6.2.1 案例
                                                                                                                                              • 6.2.2 指针变量的初始化
                                                                                                                                                • 6.2.3 指针变量的运算
                                                                                                                                                • 6.3 成绩统计及计算
                                                                                                                                                  • 6.3.1 案例
                                                                                                                                                    • 6.3.2 指向一维数组的指针
                                                                                                                                                      • 6.3.3 指向一维数组的指针运算
                                                                                                                                                      • 6.4 N阶矩阵的运算
                                                                                                                                                        • 6.4.1 案例
                                                                                                                                                          • 6.4.2 二维数组与行指针
                                                                                                                                                            • 6.4.3 数组名作为函数的参数
                                                                                                                                                            • 6.5 字符串排序
                                                                                                                                                              • 6.5.1 案例
                                                                                                                                                                • 6.5.2 指针数组
                                                                                                                                                                  • 6.5.3 指向字符串的指针
                                                                                                                                                                  • 6.6 N的阶乘
                                                                                                                                                                    • 6.6.1 案例
                                                                                                                                                                      • 6.6.2 函数的递归调用
                                                                                                                                                                      • 6.7 不确定数据量问题的处理
                                                                                                                                                                        • 6.7.1 案例
                                                                                                                                                                          • 6.7.2 内存动态分配
                                                                                                                                                                          • 6.8 查询最长字符串
                                                                                                                                                                            • 6.8.1 案例
                                                                                                                                                                              • 6.8.2 返回指针的函数
                                                                                                                                                                              • 6.9 实验内容及指导
                                                                                                                                                                                • 习题6
                                                                                                                                                                                • 第7章 结构体
                                                                                                                                                                                  • 7.1 单个学生信息的输入输出
                                                                                                                                                                                    • 7.1.1 案例
                                                                                                                                                                                      • 7.1.2 结构类型的定义
                                                                                                                                                                                        • 7.1.3 结构变量的定义及初始化
                                                                                                                                                                                          • 7.1.4 用typedef定义类型
                                                                                                                                                                                            • 7.1.5 结构成员的引用
                                                                                                                                                                                              • 7.1.6 结构变量作为函数的参数
                                                                                                                                                                                              • 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
                                                                                                                                                                                                                        • 第8章 文件
                                                                                                                                                                                                                          • 8.1 按字符方式读写文件
                                                                                                                                                                                                                            • 8.1.1 案例
                                                                                                                                                                                                                              • 8.1.2 文件的打开与关闭
                                                                                                                                                                                                                                • 8.1.3 按字符方式读写文件
                                                                                                                                                                                                                                  • 8.1.4 检测文件结束函数feof( )
                                                                                                                                                                                                                                  • 8.2 按行读写文件
                                                                                                                                                                                                                                    • 8.2.1 案例
                                                                                                                                                                                                                                      • 8.2.2 按行读写文件
                                                                                                                                                                                                                                      • 8.3 按格式读写文件
                                                                                                                                                                                                                                        • 8.3.1 案例
                                                                                                                                                                                                                                          • 8.3.2 按格式读写文件
                                                                                                                                                                                                                                          • 8.4 按块读写文件
                                                                                                                                                                                                                                            • 8.4.1 案例
                                                                                                                                                                                                                                              • 8.4.2 按块读写文件
                                                                                                                                                                                                                                              • 8.5 实验内容及指导
                                                                                                                                                                                                                                                • 习题8
                                                                                                                                                                                                                                                • 第9章 综合案例
                                                                                                                                                                                                                                                  • 9.1 高效计算
                                                                                                                                                                                                                                                    • 9.1.1 案例
                                                                                                                                                                                                                                                      • 9.1.2 位运算符
                                                                                                                                                                                                                                                      • 9.2 十进制转换为R进制数
                                                                                                                                                                                                                                                        • 9.2.1 案例
                                                                                                                                                                                                                                                          • 9.2.2 合理使用指针
                                                                                                                                                                                                                                                          • 9.3 学生基本信息管理
                                                                                                                                                                                                                                                            • 9.3.1 案例
                                                                                                                                                                                                                                                              • 9.3.2 多函数间信息交换的问题
                                                                                                                                                                                                                                                            • 附录A 常用字符与ASCII代码对照表
                                                                                                                                                                                                                                                              • 附录B C语言中的关键字
                                                                                                                                                                                                                                                                • 附录C 运算符的优先级与结合性

                                                                                                                                                                                                                                                                相关图书