顶部
收藏

C语言程序设计


作者:
刘达明 聂永萍 陈昌志 王宁 代永亮
定价:
32.00 元
版面字数:
540千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
2014年
ISBN:
978-7-04-036770-6
物料号:
36770-00
出版时间:
2013-01-25
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

本书结合计算机等级考试大纲和要求,由浅入深全面介绍ANSIC,不仅涵盖C语言的基本知识,而且注重C语言程序的详细讲解。

全书共13章,第1章主要介绍C语言的概貌,第2~4章主要介绍C语言的基础语法知识和三种基本结构程序设计,第5章主要以函数知识为背景介绍模块化程序设计,第6~9章主要介绍指针和数组,第10章主要介绍结构体和共用体构造数据类型及其指针,第11章主要介绍文件处理程序设计,第12和13章是C语言指针的高级应用和位运算。

本书内容全面、层次清晰、逻辑性强、例题丰富、通俗易懂。各章以问题分析与实现入手,重点讲述章节知识点,并通过实例巩固知识点,环环相扣,层层推进,达到通俗易懂的效果,还依据计算机等级考试题型配备了大量习题和模拟练习题。

本书既可以作为高等院校非计算机专业的C语言程序设计课程教材,也可以作为计算机类专业的相应课程教材,还可以作为读者自学和C语言程序开发人员的极佳参考书。另外本教材还配备有枟C语言程序设计实验与习题解答枠辅助教材。

  • 目录
    • 第1章 C语言概述
      • 1.1 认识程序
        • 1.1.1 直观理解程序
          • 1.1.2 计算机程序
          • 1.2 C语言程序概述
            • 1.2.1 C语言的发展
              • 1.2.2 C语言的特点
                • 1.2.3 C语言的作用
                  • 1.2.4 C语言程序的组成
                    • 1.2.5 C语言程序书写规则
                    • 1.3 C语言程序上机运行
                      • 1.3.1 C语言程序上机步骤
                        • 1.3.2 TC环境下的程序运行
                          • 1.3.3 VC环境下的程序运行
                          • 本章小结
                            • 习题1
                            • 第2章 简单C语言程序设计
                              • 2.1 计算圆周长和面积
                                • 2.1.1 分析问题
                                  • 2.1.2 程序实现
                                  • 2.2 常量与变量
                                    • 2.2.1 关键字与标识符
                                      • 2.2.2 常量
                                        • 2.2.3 变量
                                        • 2.3 C语言数据类型
                                          • 2.3.1 整型数据
                                            • 2.3.2 浮点型数据
                                              • 2.3.3 字符型数据
                                                • 2.3.4 枚举类型
                                                • 2.4 运算符与表达式
                                                  • 2.4.1 C语言运算符与表达式简介
                                                    • 2.4.2 算术运算符与算术表达式
                                                      • 2.4.3 赋值运算符与赋值表达式
                                                        • 2.4.4 条件运算符与条件表达式
                                                          • 2.4.5 逗号运算符与逗号表达式
                                                            • 2.4.6 sizeof 运算符
                                                            • 2.5 C语句概述
                                                              • 2.6 数据的输入输出
                                                                • 2.6.1 字符数据的输入与输出
                                                                  • 2.6.2 格式输入与输出
                                                                  • 2.7 预处理命令
                                                                    • 2.7.1 宏定义
                                                                      • 2.7.2 文件包含
                                                                      • 2.8 顺序结构程序设计
                                                                        • 本章小结
                                                                          • 习题2
                                                                          • 第3章 选择结构程序设计
                                                                            • 3.1 判断闰年
                                                                              • 3.1.1 分析问题
                                                                                • 3.1.2 程序实现
                                                                                • 3.2 关系运算符与关系表达式
                                                                                  • 3.3 逻辑运算符与逻辑表达式
                                                                                    • 3.4 if 语句
                                                                                      • 3.5 switch语句
                                                                                        • 3.6 选择结构的嵌套
                                                                                          • 3.7 应用实例
                                                                                            • 本章小结
                                                                                              • 习题3
                                                                                              • 第4章 循环结构程序设计
                                                                                                • 4.1 计算若干自然数的和
                                                                                                  • 4.1.1 分析问题
                                                                                                    • 4.1.2 程序实现
                                                                                                    • 4.2 自增自减运算符
                                                                                                      • 4.3 while 循环
                                                                                                        • 4.4 do-while 循环
                                                                                                          • 4.5 for 循环
                                                                                                            • 4.6 嵌套循环
                                                                                                              • 4.7 break 语句和continue 语句
                                                                                                                • 4.8 应用实例
                                                                                                                  • 本章小结
                                                                                                                    • 习题4
                                                                                                                    • 第5章 模块化程序设计
                                                                                                                      • 5.1 求三个数的最大值与
                                                                                                                        • 最小值的差
                                                                                                                          • 5.1.1 分析问题
                                                                                                                            • 5.1.2 程序实现
                                                                                                                            • 5.2 模块化程序设计思想
                                                                                                                              • 5.3 函数的定义
                                                                                                                                • 5.4 函数的调用
                                                                                                                                  • 5.4.1 函数的调用形式
                                                                                                                                    • 5.4.2 函数的参数传递
                                                                                                                                      • 5.4.3 函数的返回值
                                                                                                                                      • 5.5 函数的声明
                                                                                                                                        • 5.6 函数的嵌套调用
                                                                                                                                          • 5.7 函数的递归调用
                                                                                                                                            • 5.8 变量的作用域
                                                                                                                                              • 5.9 变量的存储类型
                                                                                                                                                • 5.10 内部函数和外部函数
                                                                                                                                                  • 5.11 应用实例
                                                                                                                                                    • 本章小结
                                                                                                                                                      • 习题5
                                                                                                                                                      • 第6章 初识指针1
                                                                                                                                                        • 6.1 交换两个变量的值1
                                                                                                                                                          • 6.1.1 分析问题1
                                                                                                                                                            • 6.1.2 程序实现
                                                                                                                                                            • 6.2 指针的概念
                                                                                                                                                              • 6.2.1 地址与指针的概念
                                                                                                                                                                • 6.2.2 取地址运算符和指针运算符4
                                                                                                                                                                  • 6.2.3 指针变量的定义与引用
                                                                                                                                                                  • 6.3 指针变量作函数参数
                                                                                                                                                                    • 6.4 应用实例
                                                                                                                                                                      • 本章小结
                                                                                                                                                                        • 习题6
                                                                                                                                                                        • 第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.4 一维数组及其指针作函数参数135
                                                                                                                                                                                        • 7.5 应用实例
                                                                                                                                                                                          • 本章小结
                                                                                                                                                                                            • 习题7
                                                                                                                                                                                            • 第8章 二维数组及其指针
                                                                                                                                                                                              • 8.1 打印九九乘法表
                                                                                                                                                                                                • 8.1.1 分析问题
                                                                                                                                                                                                  • 8.1.2 程序实现
                                                                                                                                                                                                  • 8.2 二维数组
                                                                                                                                                                                                    • 8.2.1 二维数组的定义与初始化
                                                                                                                                                                                                      • 8.2.2 二维数组的引用
                                                                                                                                                                                                      • 8.3 指向二维数组的指针
                                                                                                                                                                                                        • 8.3.1 二维数组的地址
                                                                                                                                                                                                          • 8.3.2 列指针
                                                                                                                                                                                                            • 8.3.3 行指针
                                                                                                                                                                                                            • 8.4 二维数组及其指针作函数参数166
                                                                                                                                                                                                              • 8.4.1 二维数组作函数参数
                                                                                                                                                                                                                • 8.4.2 指向二维数组的指针作函数参数
                                                                                                                                                                                                                • 8.5 应用实例
                                                                                                                                                                                                                  • 本章小结
                                                                                                                                                                                                                    • 习题8
                                                                                                                                                                                                                    • 第9章 字符数组及其指针
                                                                                                                                                                                                                      • 9.1 比较两个字符串的大小
                                                                                                                                                                                                                        • 9.1.1 分析问题
                                                                                                                                                                                                                          • 9.1.2 程序实现
                                                                                                                                                                                                                          • 9.2 字符数组
                                                                                                                                                                                                                            • 9.2.1 字符数组的定义与初始化
                                                                                                                                                                                                                              • 9.2.2 字符串与字符数组
                                                                                                                                                                                                                              • 9.3 指向字符数组的指针
                                                                                                                                                                                                                                • 9.4 字符数组及其指针作函数参数
                                                                                                                                                                                                                                  • 9.5 字符串处理函数
                                                                                                                                                                                                                                    • 9.6 应用实例
                                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                                        • 习题9
                                                                                                                                                                                                                                        • 第10章 构造数据类型
                                                                                                                                                                                                                                          • 10.1 输出学生成绩信息
                                                                                                                                                                                                                                            • 10.1.1 分析问题
                                                                                                                                                                                                                                              • 10.1.2 程序实现
                                                                                                                                                                                                                                              • 10.2 结构体变量
                                                                                                                                                                                                                                                • 10.2.1 结构体变量的定义与初始化09
                                                                                                                                                                                                                                                  • 10.2.2 结构体变量的引用
                                                                                                                                                                                                                                                  • 10.3 结构体数组
                                                                                                                                                                                                                                                    • 10.3.1 结构体数组的定义与初始化15
                                                                                                                                                                                                                                                      • 10.3.2 结构体数组的引用
                                                                                                                                                                                                                                                      • 10.4 结构体及其指针
                                                                                                                                                                                                                                                        • 10.4.1 指向结构体变量的指针
                                                                                                                                                                                                                                                          • 10.4.2 指向结构体数组的指针
                                                                                                                                                                                                                                                            • 10.4.3 结构体及其指针作函数参数21
                                                                                                                                                                                                                                                            • 10.5 共用体类型
                                                                                                                                                                                                                                                              • 10.5.1 读取一个整型数据的高字节数据
                                                                                                                                                                                                                                                                • 10.5.2 共用体变量的定义
                                                                                                                                                                                                                                                                  • 10.5.3 共用体变量的引用
                                                                                                                                                                                                                                                                  • 10.6 使用typedef 定义数据类型的别名
                                                                                                                                                                                                                                                                    • 10.7 应用实例
                                                                                                                                                                                                                                                                      • 本章小结
                                                                                                                                                                                                                                                                        • 习题10
                                                                                                                                                                                                                                                                        • 第11章 文件处理程序设计
                                                                                                                                                                                                                                                                          • 11.1 复制文件
                                                                                                                                                                                                                                                                            • 11.1.1 分析问题
                                                                                                                                                                                                                                                                              • 11.1.2 程序实现
                                                                                                                                                                                                                                                                              • 11.2 文件的基本概念
                                                                                                                                                                                                                                                                                • 11.3 打开与关闭文件
                                                                                                                                                                                                                                                                                  • 11.4 文件的出错检查
                                                                                                                                                                                                                                                                                    • 11.5 顺序读写文件数据
                                                                                                                                                                                                                                                                                      • 11.5.1 读写一个字符
                                                                                                                                                                                                                                                                                        • 11.5.2 读写一个字符串
                                                                                                                                                                                                                                                                                          • 11.5.3 格式化方式读写数据
                                                                                                                                                                                                                                                                                            • 11.5.4 二进制方式读写数据
                                                                                                                                                                                                                                                                                            • 11.6 随机读写文件数据
                                                                                                                                                                                                                                                                                              • 11.6.1 文件定位
                                                                                                                                                                                                                                                                                                • 11.6.2 随机文件的读写
                                                                                                                                                                                                                                                                                                • 11.7 应用实例
                                                                                                                                                                                                                                                                                                  • 本章小结
                                                                                                                                                                                                                                                                                                    • 习题11
                                                                                                                                                                                                                                                                                                    • 第12章 指针的高级应用
                                                                                                                                                                                                                                                                                                      • 12.1 函数与指针
                                                                                                                                                                                                                                                                                                        • 12.1.1 返回指针的函数
                                                                                                                                                                                                                                                                                                          • 12.1.2 指向函数的指针
                                                                                                                                                                                                                                                                                                          • 12.2 带参数的main 函数
                                                                                                                                                                                                                                                                                                            • 12.2.1 指针数组
                                                                                                                                                                                                                                                                                                              • 12.2.2 指向指针的指针
                                                                                                                                                                                                                                                                                                                • 12.2.3 指针数组作main 函数的形参72
                                                                                                                                                                                                                                                                                                                • 12.3 动态内存分配函数
                                                                                                                                                                                                                                                                                                                  • 12.4 链表
                                                                                                                                                                                                                                                                                                                    • 12.4.1 链表概述
                                                                                                                                                                                                                                                                                                                      • 12.4.2 自引用结构
                                                                                                                                                                                                                                                                                                                        • 12.4.3 链表的建立与输出
                                                                                                                                                                                                                                                                                                                          • 12.4.4 链表的插入与删除
                                                                                                                                                                                                                                                                                                                          • 12.5 动态数组
                                                                                                                                                                                                                                                                                                                            • 本章小结
                                                                                                                                                                                                                                                                                                                              • 习题12
                                                                                                                                                                                                                                                                                                                              • 第13章 位运算
                                                                                                                                                                                                                                                                                                                                • 13.1 位运算符与位运算
                                                                                                                                                                                                                                                                                                                                  • 13.1.1 位运算符
                                                                                                                                                                                                                                                                                                                                    • 13.1.2 位运算
                                                                                                                                                                                                                                                                                                                                    • 13.2 位段
                                                                                                                                                                                                                                                                                                                                      • 13.3 应用实例
                                                                                                                                                                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                                                                                                                                                                          • 习题13
                                                                                                                                                                                                                                                                                                                                          • 附录A ASCII 码表
                                                                                                                                                                                                                                                                                                                                            • 附录B C库函数
                                                                                                                                                                                                                                                                                                                                              • 附录C Turbo C2.0 和Visual c++6.0编程环境中的常见错误03
                                                                                                                                                                                                                                                                                                                                                • 附录D 计算机等级考试模拟
                                                                                                                                                                                                                                                                                                                                                  • 练习
                                                                                                                                                                                                                                                                                                                                                    • 参考文献

                                                                                                                                                                                                                                                                                                                                                    相关图书