顶部
收藏

C程序设计

教育部推荐教学用书

作者:
赵山林
定价:
29.80 元
版面字数:
550千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
2024年
ISBN:
978-7-04-030153-3
物料号:
30153-00
出版时间:
2010-08-12
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

本书以“零基础”为起点,首先阐述了学习C语言必备的计算机和程序设计的基础知识,然后以C语言语法和句法的规则、程序设计方法和计算机思维的培养为重点,以应用为主线,由浅入深地阐述了C语言的数据类型、结构化、模块化等知识点,归纳了选择、循环结构算法的设计思路及函数设计方法,配以大量的实例详细阐述了解决实际问题的程序设计方法。

本书可以作为高等学校计算机及相关专业学生学习C语言程序设计的教材,也可作为参加有关考试和自学的参考书。

  • 目录
    • 前辅文
      • 第1章 计算机基础知识
        • 1.1 计算机硬件系统的组成及工作原理
          • 1.1.1 计算机硬件系统的组成
            • 1.1.2 计算机的工作原理
            • 1.2 数制及数据的存储
              • 1.2.1 数制
                • 1.2.2 计算机中数据的表示
                  • 1.2.3 数制间的转换
                    • 1.2.4 数据在内存中的存储
                    • 1.3 计算机软件系统的组成
                      • 1.3.1 软件系统
                        • 1.3.2 机器语言和高级语言
                      • 第2章 C语言程序设计基础
                        • 2.1 利用计算机解决实际问题的具体步骤
                          • 2.2 算法初步
                            • 2.2.1 算法的概念和特性
                              • 2.2.2 算法的表示
                              • 2.3 结构化程序设计
                                • 2.3.1 结构化程序设计概念
                                  • 2.3.2 结构化程序设计原则
                                  • 2.4 C语言简介
                                    • 2.4.1 C语言的产生与发展
                                      • 2.4.2 C语言的特点
                                      • 2.5 C语言的基本符号
                                        • 2.5.1 C语言的字符集
                                          • 2.5.2 C语言的词汇
                                          • 2.6 C语言程序的基本结构
                                          • 第3章 数据类型及表达式
                                            • 3.1 数据结构
                                              • 3.2 C程序中数据的表示方法
                                                • 3.2.1 常量
                                                  • 3.2.2 变量
                                                  • 3.3 运算符及其表达式
                                                    • 3.3.1 C运算符概述
                                                      • 3.3.2 算术运算符及算术表达式
                                                        • 3.3.3 赋值运算符和赋值表达式
                                                          • 3.3.4 自增自减运算符及含自增自减运算的表达式
                                                            • 3.3.5 位运算
                                                              • 3.3.6 逗号运算符和逗号表达式
                                                                • 3.3.7 表达式小结
                                                                • 3.4 C语言中的类型转换
                                                                  • 3.4.1 类型的自动转换
                                                                    • 3.4.2 强制类型转换
                                                                    • 习题
                                                                    • 第4章 顺序结构程序设计
                                                                      • 4.1 C语句概述
                                                                        • 4.1.1 语句的概念
                                                                          • 4.1.2 C语句的分类
                                                                          • 4.2 输出和输入函数
                                                                            • 4.2.1 putchar()和getchar()函数
                                                                              • 4.2.2 printf()和scanf()函数
                                                                              • 4.3 顺序结构程序设计示例
                                                                                • 习题
                                                                                • 第5章 选择结构程序设计
                                                                                  • 5.1 条件的表示
                                                                                    • 5.1.1 逻辑量的概念
                                                                                      • 5.1.2 关系表达式
                                                                                        • 5.1.3 逻辑表达式
                                                                                          • 5.1.4 条件表达式
                                                                                          • 5.2 if语句
                                                                                            • 5.2.1 if语句
                                                                                              • 5.2.2 if语句的嵌套
                                                                                                • 5.2.3 选择结构程序设计示例
                                                                                                • 5.3 switch语句
                                                                                                  • 5.3.1 switch语句
                                                                                                    • 5.3.2 switch语句在多分支程序设计中的应用
                                                                                                    • 习题
                                                                                                    • 第6章 循环结构程序设计
                                                                                                      • 6.1 循环的概念
                                                                                                        • 6.2 实现循环的语句
                                                                                                          • 6.2.1 while语句
                                                                                                            • 6.2.2 do while语句
                                                                                                              • 6.2.3 for语句
                                                                                                              • 6.3 break和continue语句
                                                                                                                • 6.4 循环的嵌套
                                                                                                                  • 6.5 循环结构程序设计
                                                                                                                    • 习题
                                                                                                                    • 第7章 函数
                                                                                                                      • 7.1 函数概述
                                                                                                                        • 7.1.1 模块化程序设计思想
                                                                                                                          • 7.1.2 函数概述
                                                                                                                            • 7.1.3 函数的分类
                                                                                                                            • 7.2 函数的定义
                                                                                                                              • 7.2.1 函数的定义形式
                                                                                                                                • 7.2.2 函数的返回值
                                                                                                                                • 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.5 函数示例
                                                                                                                                                • 习题
                                                                                                                                                • 第8章 数组
                                                                                                                                                  • 8.1 数组的基本概念
                                                                                                                                                    • 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 字符数组示例
                                                                                                                                                                        • 习题
                                                                                                                                                                        • 第9章 指针
                                                                                                                                                                          • 9.1 指针的基本概念
                                                                                                                                                                            • 9.1.1 变量的直接访问和间接访问
                                                                                                                                                                              • 9.1.2 指针与指针变量
                                                                                                                                                                              • 9.2 指针变量
                                                                                                                                                                                • 9.2.1 指针变量的类型和指针变量指向变量的关系
                                                                                                                                                                                  • 9.2.2 指针变量的引用
                                                                                                                                                                                    • 9.2.3 指针的运算
                                                                                                                                                                                      • 9.2.4 指针变量作为函数参数
                                                                                                                                                                                      • 9.3 数组与指针
                                                                                                                                                                                        • 9.3.1 指向数组元素的指针变量
                                                                                                                                                                                          • 9.3.2 一维数组作函数参数和指向变量的指针变量作函数参数的一致性
                                                                                                                                                                                            • 9.3.3 多维数组的指针
                                                                                                                                                                                              • 9.3.4 字符串和指针
                                                                                                                                                                                              • 9.4 指向函数的指针和返回指针值的函数
                                                                                                                                                                                                • 9.4.1 指向函数的指针
                                                                                                                                                                                                  • 9.4.2 指向函数的指针变量
                                                                                                                                                                                                    • 9.4.3 指向函数的指针变量作函数参数
                                                                                                                                                                                                      • 9.4.4 返回指针值的函数
                                                                                                                                                                                                      • 9.5 指针数组与多级指针
                                                                                                                                                                                                        • 9.5.1 指针数组
                                                                                                                                                                                                          • 9.5.2 多级指针
                                                                                                                                                                                                            • 9.5.3 命令行参数
                                                                                                                                                                                                            • 习题
                                                                                                                                                                                                            • 第10章 结构体与联合体
                                                                                                                                                                                                              • 10.1 结构体的概念
                                                                                                                                                                                                                • 10.1.1 结构体类型的定义
                                                                                                                                                                                                                  • 10.1.2 结构体变量的定义、引用、初始化
                                                                                                                                                                                                                    • 10.1.3 结构体的嵌套
                                                                                                                                                                                                                    • 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 位字段结构体变量成员的引用
                                                                                                                                                                                                                                    • 10.5 链表
                                                                                                                                                                                                                                      • 10.5.1 链表的概念
                                                                                                                                                                                                                                        • 10.5.2 内存的动态存储、分配与释放函数
                                                                                                                                                                                                                                          • 10.5.3 链表的操作
                                                                                                                                                                                                                                          • 10.6 联合体数据类型
                                                                                                                                                                                                                                            • 10.6.1 联合体的定义
                                                                                                                                                                                                                                              • 10.6.2 联合体变量的引用
                                                                                                                                                                                                                                              • 10.7 自定义类型
                                                                                                                                                                                                                                                • 习题
                                                                                                                                                                                                                                                • 第11章 文件
                                                                                                                                                                                                                                                  • 11.1 文件概述
                                                                                                                                                                                                                                                    • 11.1.1 文件的概念
                                                                                                                                                                                                                                                      • 11.1.2 缓冲文件系统
                                                                                                                                                                                                                                                      • 11.2 文件的使用
                                                                                                                                                                                                                                                        • 11.2.1 文件类型指针
                                                                                                                                                                                                                                                          • 11.2.2 文件的打开
                                                                                                                                                                                                                                                            • 11.2.3 文件的关闭
                                                                                                                                                                                                                                                              • 11.2.4 文件的读写
                                                                                                                                                                                                                                                                • 11.2.5 文件的定位
                                                                                                                                                                                                                                                                  • 11.2.6 文件的检测
                                                                                                                                                                                                                                                                  • 11.3 文件程序设计示例
                                                                                                                                                                                                                                                                    • 习题
                                                                                                                                                                                                                                                                    • 第12章 编译预处理
                                                                                                                                                                                                                                                                      • 12.1 宏定义
                                                                                                                                                                                                                                                                        • 12.1.1 不带参数的宏定义
                                                                                                                                                                                                                                                                          • 12.1.2 带参数的宏定义
                                                                                                                                                                                                                                                                          • 12.2 文件包含
                                                                                                                                                                                                                                                                            • 12.3 条件编译
                                                                                                                                                                                                                                                                              • 习题
                                                                                                                                                                                                                                                                              • 附录1 ASCII字符表
                                                                                                                                                                                                                                                                                • 附录2 C语言的运算符及优先级和结合性
                                                                                                                                                                                                                                                                                  • 附录3 Visual C++6.0集成开发环境
                                                                                                                                                                                                                                                                                    • 附录4 常用标准库函数

                                                                                                                                                                                                                                                                                    相关图书