C语言程序设计教程

第1章  绪论                  
 1. 1  程序设计语言的发展                  
 1. 2  程序设计的基本过程                  
 1. 3  程序设计的基本方法                  
 1. 3. 1  结构化程序设计                  
 1. 3. 2  模块化程序设计                  
 1. 3. 3  自顶向下. 逐步细化的设计过程                  
 习题1                  
 第2章  C程序的基本组成                  
 2. 1  简单的C语言程序                  
 2. 2  基本数据类型变量的定义与宏定义                  
 2. 2. 1  整型常量及其变量的定义                  
 2. 2. 2  实型常量及其变量的定义                  
 2. 2. 3  字符型常量及其变量的定义                  
 2. 3  数据的输入与输出                  
 2. 3. 1  格式输出函数                  
 2. 3. 2  格式输入函数                  
 2. 3. 3  字符输出函数                  
 2. 3. 4  字符输入函数                  
 2. 4  数据的处理                  
 2. 4. 1  赋值运算                  
 2. 4. 2  算术运算                  
 2. 4. 3  关系运算                  
 2. 4. 4  逻辑运算                  
 2. 4. 5  增1与减1运算符                  
 2. 4. 6  sizeof运算符                  
 2. 4. 7  逗号运算符                  
 2. 4. 8  标准函数                  
 2. 5  宏定义                  
 2. 5. 1  符号常量定义                  
 2. 5. 2  带参数的宏定义                  
 习题2                  
 第3章  选择结构                  
 3. 1  语句与复合语句                  
 3. 2  if语句                  
 3. 3  if...else结构                  
 3. 4  条件运算符                  
 3. 5  switch结构                  
 3. 6  程序举例                  
 习题3                  
 第4章  循环结构                  
 4. 1  当型循环与直到型循环                  
 4. 1. 1  当型循环结构                  
 4. 1. 2  直到型循环结构                  
 4. 1. 3  当型循环结构与直到型循环结构的区别与联系                  
 4. 2  for循环                  
 4. 3  循环的嵌套与其他有关语句                  
 4. 3. 1  循环的嵌套                  
 4. 3. 2  break语句                  
 4. 3. 3  con6nue语句                  
 4. 4  程序举例                  
 4. 4. 1  列举算法                  
 4. 4. 2  密码问题                  
 4. 4. 3  对分法求方程实根                  
 4. 4. 4  迭代法求方程实根                  
 4. 4. 5  牛顿法求方程实根                  
 4. 4. 6  梯形法求定积分                  
 习题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. 2. 4  内部函数与外部函数                  
 5. 3  模块的递归调用                  
 5. 4  程序举例                  
 5. 5  编译预处理                  
 5. 5. 1  文件包含命令                  
 5. 5. 2  条件编译命令                  
 习题5                  
 第6章  数组                  
 6. 1  一维数组                  
 6. 1. 1  一维数组的定义与引用                  
 6. 1. 2  一维数组的初始化                  
 6. 2  二维数组                  
 6. 2. 1  二维数组的定义与引用                  
 6. 2. 2  二维数组的初始化                  
 6. 3  字符数组与字符串                  
 6. 3. 1  字符数组的定义与初始化                  
 6. 3. 2  字符串                  
 6. 3. 3  字符数组与字符串的输入与输出                  
 6. 3. 4  字符串处理函数                  
 6. 4  数组作为函数参数                  
 6. 4. 1  形参数组与实参数组的结合                  
 6. 4. 2  二维数组作为函数参数                  
 6. 5  程序举例                  
 习题6                  
 第7章  指针                  
 7. 1  指针的基本概念                  
 7. 2  指针变量                  
 7. 2. 1  指针变量的定义与引用                  
 7. 2. 2  指针变量作为函数参数                  
 7. 3  数组与指针                  
 7. 3. 1  数组的指针与数组元素的指针                  
 7. 3. 2  数组指针作为函数参数                  
 7. 3. 3  多维数组与指针                  
 7. 4  字符串与指针                  
 7. 4. 1  字符串指针                  
 7. 4. 2  字符串指针作为函数参数                  
 7. 5  指针数组与指向指针的指针                  
 7. 5. 1  指针数组的概念                  
 7. 5. 2  指向指针的指针                  
 7. 5. 3  main函数的形参                  
 7. 6  函数与指针                  
 7. 6. 1  用函数指针变量调用函数                  
 7. 6. 2  数指针变量作为函数参数                  
 7. 7  程序举例                  
 习题7                  
 第8章  结构体与联合体                  
 8. 1  结构体类型变量                  
 8. 1. 1  结构体类型变量的定义                  
 8. 1. 2  结构体类型变量的引用                  
 8. 1. 3  结构体的嵌套                  
 8. 1. 4  结构体类型变量的初始化                  
 8. 1. 5  结构体与函数                  
 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. 6  枚举类型与自定义类型名                  
 8. 6. 1  枚举类型                  
 8. 6. 2  自定义类型名                  
 8. 7  程序举例                  
 习题8                  
 第9章  文件                  
 9. 1  文件的概念                  
 9. 1. 1  文本文件与二进制文件                  
 9. 1. 2  缓冲文件系统                  
 9. 1. 3  文件类型指针                  
 9. 2  文件的打开与关闭                  
 9. 2. 1  文件的打开                  
 9. 2. 2  文件的关闭                  
 9. 3  文件的读写                  
 9. 3. 1  文件读函数                  
 9. 3. 2  文件写函数                  
 9. 4  文件的定位                  
 9. 5  程序举例                  
 习题9                  
 第10章  位运算                  
 10. 1  进制位运算                  
 10. 2  位段                  
 10. 3  程序举例                  
 习题10                  
 附录1  基本ASCII码表                  
 附录2  TurboC常用库函数                  
 参考文献