EEWORLD下载中心鼎力奉献“写给大家看的C语言书”，让你轻松玩转C语言

tiankai001

EEWORLD下载中心鼎力奉献“写给大家看的C语言书”，让你轻松玩转C语言 [复制链接]

 

 

EEWORLD下载中心鼎力奉献“写给大家看的C语言书”，让你轻松玩转C语言

EEWORLD下载中心正式上线一年多了，现在资源数量已经超过50万，这与广大网友的关注和努力是分不开的。

对于一个资源中心来书，10万的资源数量已经囊括了日常所用资源的绝大部分，大家需要的常用资源都可以从资源中心搜索出来。

但是，有时候我们搜索资源是很有针对性的，搜的时候需要非常准确的关键词才能搜到。从而导致很多非常好的资源，因为名字或者关键词的不完善，一直处于“养在深闺人未知“的状况下。

虽然我们对于好的资源可以用“酒香不怕巷子深”这样的话来自我安慰，但是在如今的互联网时代，早已是“酒香也怕巷子深“了，否则电视，网络等各种媒体里面就不会到处都铺满广告了。

既然如此，我们就需要对资源进行优化组合，尽量吧相关性强的优质资源整合在一起，是大家能够在搜索资源的时候实现：搜索一个、得到多个。甚至会搜到比我们预期更好的资源。

现在我们就对资源的优化组合进行一个初步尝试，这开始的第一个对象，就选择目前嵌入式系统编程中必然绕不开的话题“C语言”。

关于“C语言”的资料在网上是多如牛毛，这次我们的重点是集中搜集国外的优秀C语言书籍。俗话说，它山之石可以攻玉，那我们就借鉴一下国外的优秀C语言教材，是我们能够彻底玩转C语言。

之所以选择帖子题目为“写给大家看的C语言书”，一是确实有一本书名字就叫做《写给大家看的C语言书》，这本书就是讲解C语言的入门教程；二是这个名字确实非常符合我们这个帖子的主题；三是希望借助这个很有吸引力的名字来激发大家更多的兴趣。

好了，废话说到这里为止，下面切入正题。

我们搜集了尽可能全的网上的国外C语言教材书籍，共计18本，全部提供完整电子版本，然后给出这些书籍在下载中心的链接，大家可以直接去下载。最后是在帖子后面尽量给出这些书籍的简介和目录，一边让大家能够对这些书籍有个大致了解，是大家可以按需下载。

最后，有个希望：希望大家能够对我们这个专题整理积极进行完善和提出建议。我们目前只搜集了18本，网上应该还有更多国外的优秀C语言书籍，如果大家有我们没有列出的国外C语言书籍，请在帖子后面跟帖列出，最好将这些书籍上传到资源中心。对于提供了本贴中没有列出的国外C语言书籍，并且将资料上传到资源中心的朋友，我们将进行奖励：只要你上传了一本我们没有列出的国外C语言书籍，我们就会额外赠送10分下载积分。如有上传，请把链接复制，到本帖下回复。

另外更希望大家对EE下载中心提出更多建议，建议一经采纳，就会有好礼相赠。

tiankai001

1、写给大家看的C语言书

https://download.eeworld.com.cn/detail/tiankai001/98314

2、C Primer Plus(第五版)中文版

https://download.eeworld.com.cn/detail/tiankai001/2431

3、C语言程序设计现代方法第2版

https://download.eeworld.com.cn/detail/0%E5%8C%97%E5%AE%B80/88401

4、[C和指针].(美)Kenneth.A.Reek

https://download.eeworld.com.cn/detail/MrKingMCU/56502

附：C和指针课后题答案(完整版)

https://download.eeworld.com.cn/detail/%E5%B8%B8%E8%A7%81%E6%B3%BD1/8401

5、[C语言大全](CThe.Complete.Conferrence).赫伯特.希尔特.扫描版

https://download.eeworld.com.cn/detail/tiankai001/98315

6、[C语言入门经典(第四版)].（美）霍顿.扫描版

https://download.eeworld.com.cn/detail/yuwei664/91496

7、[你必须知道的495个C语言问题]人民邮电出版社.扫描版

https://download.eeworld.com.cn/detail/xieryou/26944

8、《C语言的科学和艺术》中文版

https://download.eeworld.com.cn/detail/tiankai001/98316

9、C数值算法.(美国)William.H．Press

https://download.eeworld.com.cn/detail/tiankai001/98317

10、C语言解析教程

https://download.eeworld.com.cn/detail/tiankai001/98318

11、c语言编程常见问题解答

https://download.eeworld.com.cn/detail/tiankai001/4764

12、微软-C语言编程精粹（完整版）

https://download.eeworld.com.cn/detail/xieryou/26922

C程序设计之四书五经：包含以下几本书籍

13、C程序设计语言（第2版·新版）非扫描版&详细书签版

https://download.eeworld.com.cn/detail/xieryou/26648

附：习题解答

https://download.eeworld.com.cn/download/xieryou/26654

14、C专家编程

https://download.eeworld.com.cn/detail/Timson/22092

15、C语言参考手册第五版

https://download.eeworld.com.cn/download/xieryou/26934

16、C语言接口与实现--创建可重用软件的技术

https://download.eeworld.com.cn/detail/tiankai001/98319

17、C陷阱与缺陷

https://download.eeworld.com.cn/detail/905377346/25922

18、C大学教程(第五版).（美）戴特尔.扫描版

https://download.eeworld.com.cn/detail/xieryou/6876

tiankai001

写给大家看的C语言书

眼看着你的朋友们一个个得到C语言编程的工作而你只能被冷落在一边，你是否有些心灰意冷？你是否想学习C语言却苦于没有足够的精力？你的老旧的、磨损严重的计算机是否需要用一种热门的编程语言来提高运行速度？这本书正是医生为你对症下药开出的处方。
　　本书不像一般的计算机图书那样居高临下地说教，它站在读者的角度讲解，通俗易懂。本书就像是你最好的朋友坐在身边教你C语言。作者使用平实的语言而非“术语”。与其他书相比，本书中那些短小的章节、丰富的图示以及偶尔出现的幽默直白的讨论，能指导你更迅速、更友好、更容易地穿过C语言编程的迷宫。读者对象
　　这是一本入门书。如果你从来没有写过程序，那么这本书正好适合你。学习本书不需要任何编程概念的知识。就算你不能拼写C，也可以通过本书学会用C语言编程。
　　短语绝对初学者。（absolutebegillIler）在不同情况下有不同的意思。你以前可能尝试过学习C语言但又放弃了。许多书和培训班都给C语言强加了太多的技巧。你可能曾经用其他语言编写过程序但是刚开始学习c语言。如果是这样，请读下去，学完32章之后，你将了解C语言。本书特色
　　本书不使用那些初学者不需要的内部技术操作来云山雾罩地分析问题。作者（我）坚信应该细嚼慢咽地学好基本原理。


没有编程基础，被C语言的术语和细节搞得晕头转向，手头的教科书无数次拿起又放下、总是读不进去，甚至已经开始考虑放弃？不要灰心！《写给大家看的C语言书(第2版)》将带你开始一次轻松有趣的C语言之旅，并且使你在旅途的终点自信满满地迎接憧憬无限的明天。
　　这是一部别开生面、与众不同的C语言经典入门著作，在全球畅销已经近20年，重印数十次。书中，作者好像坐在你身边的老朋友，拉着家常，将C语言的基础知识、必备的实战技能和宝贵编程经验一一道来。没有云山雾罩，没有前因后果的行话，没有艰深而且不必要的内部技术细节，没有沉闷晦涩的长篇大论，只有生动的漫画、丰富的图示、幽默通俗的文字、细致的分析阐述、引人入胜的趣闻轶事和短小精悍的章节安排。作者不仅将重要的知识点以“线索”、“警告”、“陷阱”、“难点”、“小结”等活泼的形式呈现给读者，而且还提供了一个贯穿全书的21点游戏程序，完美地将旅途上所有的景点巧妙地嵌在其中。
　　《写给大家看的C语言书(第2版)》不仅已经成功地使无数没有编程经验的初学者包括许多十几岁的孩子掌握了C语言，也是全球许多著名高校的程序设计课程教材。
　　久负盛名的C语言神奇入门书
　　来吧，现在就开始攻克C语言
　　从这里，爱上编程


我在大学教了多年的编程课，遗憾的是，大多数教材对于初学者来说都太厚太难理解了。而本书则完全从初学者的角度来写，我强烈推荐本书给那些一直畏惧编程的学生。
　　——Bruce Conklin， Phoenix 大学老师
　　这本书带我迅速入门，它让我从此爱上了编程。
　　——　Eric M.，13岁


《写给大家看的C语言书(第2版)》是C语言的入门教程，针对没有程序设计基础的读者，详细介绍了C语言的基本概念和编辑技术。《写给大家看的C语言书(第2版)》分为5部分共32章内容，第一部分为C语言入门篇，介绍了C语言的基础知识。第二部分为运算符篇，讲解了常用的运算符以及选择结构等内容。第三部分为逻辑控制篇，讲解了各种循环结构以及各种常用的内置函数。第四部分为数组和指针篇，讲解了数组排序、搜索、指针、堆内存管理以及结构体。第五部分为函数篇，讲解了函数和文件的相关内容。
　　《写给大家看的C语言书(第2版)》适合C语言初学者作为入门教程，也可作为大、中专院校师生和培训班的教材，对于C语言开发的爱好者，《写给大家看的C语言书(第2版)》也有较大的参考价值。




第一部分 c语言初步
第1章 初识C语言
1.1 什么是程序
1.2 编写C程序需要什么
1.3 编程过程
1.4 使用c语言

第2章 从何处入手
2.1 概述
2.2 main()函数
2.3 数据类型
2.3.1 字符
2.3.2 数字
2.4 小结

第3章 代码注释
3.1 给代码加注释
3.2 注释详述
3.3 留白艺术
3.4 另一种注释方式
3.5 小结

第4章 输出
4.1 printf()做了什么
4.2 printf()的格式
4.3 打印字符串
4.4 转义序列
4.5 转化字符
4.6 小结

第5章 变量
5.1 变量类型
5.2 变量的命名
5.3 定义变量
5.4 在变量中存储数据
5.5 小结

第6章 字符串
6.1 字符串结束符
6.2 字符串的长度
6.3 字符数组：字符的列表
6.4 初始化字符串
6.5 小结

第7章 includej}口#define
7.1 包含文件
7.2 在哪里放置include指令
7.3 定义常量
7.4 小结

第8章 输入
8.1 简述scanf()
8.2 与printf()一起使用
8.3 使用scanf()的问题
8.4 小结

第9章 C怎么做数学运算
9.1 基本知识
9.2 运算符的优先级
9.3 用括号打破规则
9.4.多重赋值
9.5 小结

第二部分 操作空间
第10章 表达式还能用来做什么
10.1 复合赋值
10.2 小心优先级
10.3 强制类型转换
10.4 小结

第11章 关系运算符
11.1 测试数据
11.2 使用if语句
11.3 否则：用else语句
11.4 小结

第12章 逻辑运算符
12.1 获取逻辑
12.2 逻辑运算符的优先级
12.3 小结

第13章 更高级的运算符
13.1 条件运算符
13.2 运算符++和
13.3 运算符sizeof()
13.4 小结

第三部分 保持控制
第14章 循环
14.1 whi.1 e循环
14.2 使用while语句
14.3 使用do－while语句
14.4 小结

第15章 其他循环
15.1 为了重复
15.2 使用for循环
15.3 小结

第16章 终止循环
16.1 使用break语句
16.2 使用continue语句
16.3 小结

第17章 测试多个值
17.1 使用switch语句
17.2 switch语句中使用break语句
17.3 妙用case语句
17.4 小结

第18章 输入和输出
18.1 putchar()和getchar()函数
18.2 关于换行符的思考
18.3 getch()函数
18.4 小结

第19章 更多有关字符串的内容
19.1 字符测试函数
19.2 大小写测试函数
19.3 大小写转换函数，
19.4 字符串函数
19.5 小结

第20章 更高级的数学函数
20.1 简单的数学函数
20.2 更多的转化
20.3 三角函数和对数函数
20.4 获取随机数
20.5 小结

第四部分 c程序和大量数据
第21章 C语言如何处理列表
21.1 复习数组
21.2 数组赋值
21.3 有关数组的更多内容
21.4 小结

第22章 搜索数据
22.1 填充数组
22.2 搜索
22.3 小结

第23章 排序
23.1 排序
23.2 加快搜索
23.3 小结

第24章 我的名字叫指针
24.1 内存地址
24.2 定义指针变量
24.3 使用取值运算符
24.4 小结

第25章 数组和指针有什么不同
25.1 数组名是指针
25.2 在数组中取值
25.3 字符和指针
25.4 小心字符串的长度
25.5 指针数组
25.6 小结

第26章 有效管理内存空间
26.1 使用堆
26.2 为什么需要堆
26.3 分配堆
26.4 堆内存分配失败
26.5 释放堆内存
26.6 多次分配
26.7 小结

第27章 结构体
27.1 定义结构体
27.2 在结构体变量中存放数据
27.3 小结

第五部分 用函数组织程序
第28章 把数据存到硬盘上
28.1 硬盘文件
28.2 打开顺序文件
28.3 访问顺序文件
28.4 小结

第29章 另一种保存文件的方式
29.1 打开随机文件
29.2 访问随机文件
29.3 小结

第30章 用函数来组织程序
30.1 用C函数来组织程序
30.2 局部变量和全局变量
30.3 小结

第31章 在函数间共享数据
31.1 传递参数
31.2 传递实参的方法
31.2.1 按值传递
31.2.2 按地址传递
31.3 小结

第32章 让函数更完美
32.1 返回值.
32.2 返回的数据类型
32.3 声明函数原型
32.4.结语
32.5 小结
附录A 你可以飞得更高
附录B 玩C语言写的21点游戏
附录C ASCll表

[ 本帖最后由 tiankai001 于 2013-9-10 13:10 编辑 ]

tiankai001

《C Primer Plus<第5版>》(中文版)


《C Primer Plus<第5版>》(中文版)　 全面讲述了C语言编程的相关概念和知识。
　　《C Primer Plus<第5版>》(中文版)　适合希望系统学习C语言的读者，也适用于精通其他编程语言并希望进一步掌握和巩固C编程技术的程序员。

《C Primer Plus<第5版>》(中文版)共17章。第1、2章学习C语言编程所需的预备知识。第3到15章介绍了C语言的相关知识，包括数据类型、格式化输入输出、运算符、表达式、流程控制语句、函数、数组和指针、字符串操作、内存管理、位操作等等，知识内容都针对C99标准；另外，第10章强化了对指针的讨论，第12章引入了动态内存分配的概念，这些内容更加适合读者的需求。第16章和第17章讨论了C预处理器和C库函数、高级数据表示（数据结构）方面的内容。附录给出了各章后面复习题、编程练习的答案和丰富的C编程参考资料。


第1章 概览
1.1 C语言的起源
1.2 使用C语言的理由
1.3 C语言的发展方向
1.4 计算机工作的基本原理
1.5 高级计算机语言和编译器
1.6 使用C语言的7个步骤
1.7 编程机制
1.8 语言标准
1.9 本书的组织结构
1.10 本书体例
1.11 总结
1.12 复习题
1.13 编程练习
第2章 C语言概述
2.1 C语言的一个简单实例
2.2 实例说明
2.3 一个简单程序的结构
2.4 使程序可读的技巧
2.5 更进一步
2.6 多个函数
2.7 调试
2.8 关键字和保留标识符
2.9 关键概念
2.10 总结
2.11 复习题
2.12 编程练习
第3章 数据和C
3.1 示例程序
3.2 变量与常量数据
3.3 数据：数据类型关键字
3.4 C数据类型
3.5 使用数据类型
3.6 参数和易犯的错误
3.7 另一个例子：转义序列
3.8 关键概念
3.9 总结
3.10 复习题
3.11 编程练习
第4章 字符串和格式化输入/输出
4.1 前导程序
4.2 字符串简介
4.3 常量和C预处理器
4.4 研究和利用printf（）和scanf（）
4.5 关键概念
4.6 总结
4.7 复习题
4.8 编程练习
第5章 运算符、表达式和语句
5.1 循环简介
5.2 基本运算符
5.3 其他运算符
5.4 表达式和语句
5.5 类型转换
5.6 带有参数的函数
5.7 一个示例程序
5.8 关键概念
5.9 总结
5.10 复习题
5.11 编程练习
第6章 C控制语句：循环
6.1 再探while循环
6.2 while语句
6.4 不确定循环与计数循环
6.5 for循环
6.6 更多赋值运算符：+=、-=、*=、/=和%=
6.7 逗号运算符
6.8 退出条件循环：do while
6.9 选择哪种循环
6.10 嵌套循环
6.11 数组
6.12 使用函数返回值的循环例子
6.13 关键概念
6.14 总结
6.15 复习题
6.16 编程练习
第7章 C控制语句：分支和跳转
7.1 if语句
7.2 在if语句中添加else关键字
7.3 获得逻辑性
7.4 一个统计字数的程序
7.5 条件运算符?：
7.6 循环辅助手段：continue和break
7.7 多重选择：switch和break
7.8 goto语句
7.9 关键概念
7.10 总结
7.11 复习题
7.12 编程练习
第8章 字符输入/输出和输入确认
8.1 单字符I/O：getchar（）和putchar（）
8.2 缓冲区
8.3 终止键盘输入
8.5 创建一个更友好的用户界面
8.6 输入确认
8.7 菜单浏览
8.8 关键概念
8.9 总结
8.10 复习题
8.11 编程练习
第9章 函数
9.1 函数概述
9.2 ANSI C的函数原型
9.3 递归
9.4 多源代码文件程序的编译
9.5 地址运算符：&
9.6 改变调用函数中的变量
9.7 指针简介
9.8 关键概念
9.9 总结
9.10 复习题
9.11 编程练习
第10章 数组和指针
10.1 数组
10.2 多维数组
10.3 指针和数组
10.4 函数、数组和指针
10.5 指针操作
10.6 保护数组内容
10.7 指针和多维数组
10.8 变长数组（VLA）
10.9 复合文字
10.10 关键概念
10.11 总结
10.12 复习题
10.13 编程练习
第11章 字符串和字符串函数
11.1 字符串表示和字符串I/O
11.2 字符串输入
11.3 字符串输出
11.4 自定义字符串输入/输出函数
11.5 字符串函数
11.6 字符串例子：字符串排序
11.7 ctype.h字符函数和字符串
11.8 命令行参数
11.9 把字符串转换为数字
11.10 关键概念
11.11 总结
11.12 复习题
11.13 编程练习
第12章 存储类、链接和内存管理
12.1 存储类
12.2 存储类说明符
12.3 存储类和函数
12.4 随机数函数和静态变量
12.5 掷骰子
12.6 分配内存：malloc（）和free（）
12.7 ANSI C的类型限定词
12.8 关键概念
12.9 总结
12.10 复习题
12.11 编程练习
第13章 文件输入/输出
13.1 和文件进行通信
13.2 标准I/O
13.3 一个简单的文件压缩程序
13.4 文件I/O：fprintf ( )、fscanf ( )、fgets ( )和fputs ( )函数
13.5 随机存取：fseek（）和ftell（）函数
13.6 标准I/O内幕
13.7 其他标准I/O函数
13.8 关键概念
13.9 总结
13.10 复习题
13.11 编程练习
第14章 结构和其他数据形式
14.1 示例问题：创建图书目录
14.2 建立结构声明
14.3 定义结构变量
14.4 结构数组
14.5 嵌套结构
14.6 指向结构的指针
14.7 向函数传递结构信息
14.8 把结构内容保存到文件中
14.9 结构：下一步是什么
14.10 联合简介
14.11 枚举类型
14.12 typedef简介
14.13 奇特的声明
14.14 函数和指针
14.15 关键概念
14.16 总结
14.17 复习题
14.18 编程练习
第15章 位操作
15.1 二进制数、位和字节
15.2 其他基数
15.3 C的位运算符
15.4 位字段
15.5 关键概念
15.6 总结
15.7 复习题
15.8 编程练习
第16章 C预处理器和C库
16.1 翻译程序的第一步
16.2 明显常量：#define
16.3 在#define中使用参数
16.4 宏，还是函数
16.5 文件包含：＃include
16.6 其他指令
16.7 内联函数
16.8 C库
16.9 数学库
16.10 通用工具库
16.11 诊断库
16.12 string.h库中的memcpy（）和memmove（）
16.13 可变参数：stdarg.h
16.14 关键概念
16.15 总结
16.16 复习题
16.17 编程练习
第17章 高级数据表示
17.1 研究数据表示
17.2 从数组到链表
17.3 抽象数据类型（ADT）
17.4 队列ADT
17.5 用队列进行模拟
17.6 链表与数组
17.7 二叉搜索树
17.8 其他说明
17.9 关键概念
17.10 总结
17.11 复习题
17.12 编程练习
附录A 复习题答案
附录B 参考资料

[ 本帖最后由 tiankai001 于 2013-9-10 13:09 编辑 ]

tiankai001

C语言程序设计现代方法第2版

　时至今日，C语言仍然是计算机领域的通用语言之一，但今天的C语言已经和最初的时候大不相同了。本书最主要的一个目的就是通过一种“现代方法”来介绍C语言，书中强调标准C，强调软件工程，不再强调“手工优化”。这一版中紧密结合了C99标准，并与C89标准进行对照，补充了C99中的最新特性。本书分为C语言的基础特性、C语言的高级特性、C语言标准库和参考资料4个部分。每章末尾都有一个“问与答”小节给出一系列与该章内容相关的问题及答案，此外还包含适量的习题。
　　本书是为大学本科阶段的C语言课程编写的教材，同时也非常适合作为其他课程的辅助用书。
　　作者简介：K.N.King 世界知名的计算机程序设计教育家，佐治亚州立大学数学与计算机科学系副教授。耶鲁大学计算机科学硕士，加州大学伯克利分校计算机科学博士，曾任教于佐治亚理工学院。除本书外，他还撰写了广受欢迎的教材Java Programming：From the Beginning，并在Dr．Dobbs Journal等权威杂志上发表了许多论文。业余时间，King教授还在多部电影中扮演过角色。


　在计算领域中，把显而易见的转变为有实用价值的，这一过程是“挫折”一词的生动体现。
　　自本书第1版出版以来，基于C的语言大量兴起（其中最杰出的代表是Java和C#），已有的C++和Perl等相关语言也取得了更大的成就。尽管如此，C语言仍然像当年一样流行，仍然悄无声息地掌控着世界上的许多软件。跟1996年一样，C语言仍然是计算机领域里的通用语言。
　　但即便是C语言也必须随着时间而发展。C99标准的发布催生了对本书新版的需求，而且，第1版涉及的DOS和16位处理器也已经趋于过时。本版对内容进行了全面更新，并在其他许多方面进行了改进。
　　本版新增内容
　　下面列出了本版的新特色和所做的改进。
　　完整地覆盖了C89标准和C99标准。本版和第1版最大的差别就在于覆盖了C99标准。我的目标是覆盖C89和C99之间的每一个重要差别，包括C99新增的所有语言特性和库函数。C99中的每一处改变都会清楚地标出来，或者在小节标题中加上“C99”字样，或者在讨论比较简短时在正文的左边空白处用一个专门的图标表示。我这样做有两个目的：一是提醒读者注意C99中的改变，二是让那些对C99不感兴趣或没有C99编译器的读者知道哪些内容可以跳过。C99新增的许多内容可能只有特定的读者会感兴趣，但有些新特性几乎对所有的C程序员都有用。
　　提供了对所有C89和C99库函数的快速参考。第1版中附录D介绍了C89的所有标准库函数，本版的附录D给出了C89和C99的所有库函数。
　　扩展了GCC的内容。自本书第1版出版以来，GCC（最初是GNU C Compiler的简称，现在指GNU Compiler Collection）得到了广泛应用。GCC有很多优点，包括高性能、低成本（不用花钱）以及在众多软硬件平台之间的可移植性等。由于认识到GCC日渐重要，我在本版中介绍了更多与GCC相关的信息，包括如何使用GCC以及常见的GCC错误消息和警告。

第1章 C语言概述1
1.1 C语言的历史1
1.1.1 起源1
1.1.2 标准化1
1.1.3 基于C的语言2
1.2 C语言的优缺点3
1.2.1 C语言的优点3
1.2.2 C语言的缺点3
1.2.3 高效地使用C语言4
问与答5

第2章 C语言基本概念7
2.1 编写一个简单的C程序7
程序显示双关语7
2.1.1 编译和链接8
2.1.2 集成开发环境8
2.2 简单程序的一般形式9
2.2.1 指令9
2.2.2 函数9
2.2.3 语句10
2.2.4 显示字符串10
2.3 注释11
2.4 变量和赋值12
2.4.1 类型12
2.4.2 声明13
2.4.3 赋值13
2.4.4 显示变量的值14
程序计算箱子的空间重量14
2.4.5 初始化15
2.4.6 显示表达式的值16
2.5 读入输入16
程序计算箱子的空间重量（改进版）16
2.6 定义常量的名字17
程序华氏温度转换为摄氏温度17
2.7 标识符18
2.8 C程序的书写规范19
问与答21
练习题23
编程题24

第3章 格式化输入/输出26
3.1 printf函数26
3.1.1 转换说明27
程序用printf函数格式化数28
3.1.2 转义序列28
3.2 scanf函数29
3.2.1 scanf函数的工作方法30
3.2.2 格式串中的普通字符31
3.2.3 易混淆的printf函数和scanf函数32
程序分数相加32
问与答33
练习题34
编程题35

第4章 表达式36
4.1 算术运算符36
程序计算通用产品代码的校验位38
4.2 赋值运算符39
4.2.1 简单赋值40
4.2.2 左值41
4.2.3 复合赋值41
4.3 自增运算符和自减运算符42
4.4 表达式求值43
4.5 表达式语句45
问与答45
练习题47
编程题49

第5章 选择语句50
5.1 逻辑表达式50
5.1.1 关系运算符50
5.1.2 判等运算符51
5.1.3 逻辑运算符51
5.2 if语句52
5.2.1 复合语句53
5.2.2 else子句53
5.2.3 级联式if语句54
程序计算股票经纪人的佣金55
5.2.4 “悬空else”的问题56
5.2.5 条件表达式57
5.2.6 C89中的布尔值58
5.2.7 C99中的布尔值58
5.3 switch语句59
程序显示法定格式的日期61
问与答62
练习题65
编程题67

第6章 循环69
6.1 while语句69
程序显示平方表71
程序数列求和71
6.2 do语句72
程序计算整数的位数73
6.3 for语句73
6.3.1 for语句的惯用法74
6.3.2 在for语句中省略表达式75
6.3.3 C99中的for语句75
6.3.4 逗号运算符76
程序显示平方表（改进版）77
6.4 退出循环78
6.4.1 break语句78
6.4.2 continue语句78
6.4.3 goto语句79
程序账簿结算80
6.5 空语句81
问与答83
练习题84
编程题85

第7章 基本类型88
7.1 整数类型88
7.1.1 C99中的整数类型90
7.1.2 整数常量90
7.1.3 C99中的整数常量91
7.1.4 整数溢出91
7.1.5 读/写整数91
程序数列求和（改进版）92
7.2 浮点类型93
7.2.1 浮点常量94
7.2.2 读/写浮点数94
7.3 字符类型94
7.3.1 字符操作95
7.3.2 有符号字符和无符号字符95
7.3.3 算术类型96
7.3.4 转义序列96
7.3.5 字符处理函数97
7.3.6 用scanf和printf读/写字符98
7.3.7 用getchar和putchar读/写字符98
程序确定消息的长度99
7.4 类型转换100
7.4.1 常用算术转换101
7.4.2 赋值过程中的转换102
7.4.3 C99中的隐式转换103
7.4.4 强制类型转换103
7.5 类型定义105
7.5.1 类型定义的优点105
7.5.2 类型定义和可移植性105
7.6 sizeof运算符106
问与答107
练习题109
编程题110

第8章 数组113
8.1 一维数组113
8.1.1 数组下标113
程序数列反向115
8.1.2 数组初始化115
8.1.3 指定初始化式116
程序检查数中重复出现的数字116
8.1.4 对数组使用sizeof运算符117
程序计算利息118
8.2 多维数组119
8.2.1 多维数组初始化120
8.2.2 常量数组121
程序发牌121
8.3 C99中的变长数组122
问与答123
练习题124
编程题125

第9章 函数129
9.1 函数的定义和调用129
程序计算平均值129
程序显示倒计数130
程序显示双关语（改进版）131
9.1.1 函数定义132
9.1.2 函数调用133
程序判定素数134
9.2 函数声明135
9.3 实际参数136
9.3.1 实际参数的转换137
9.3.2 数组型实际参数138
9.3.3 变长数组形式参数140
9.3.4 在数组参数声明中使用static141
9.3.5 复合字面量141
9.4 return语句142
9.5 程序终止143
9.6 递归144
程序快速排序146
问与答147
练习题150
编程题153

第10章 程序结构155
10.1 局部变量155
10.1.1 静态局部变量156
10.1.2 形式参数156
10.2 外部变量156
10.2.1 示例：用外部变量实现栈156
10.2.2 外部变量的利与弊157
程序猜数158
10.3 程序块161
10.4 作用域162
10.5 构建C程序163
程序给一手牌分类163
问与答169
练习题169
编程题170

第11章 指针172
11.1 指针变量172
11.2 取地址运算符和间接寻址运算符173
11.2.1 取地址运算符173
11.2.2 间接寻址运算符174
11.3 指针赋值174
11.4 指针作为参数176
程序找出数组中的最大元素和最小元素177
11.5 指针作为返回值179
问与答180
练习题181
编程题182

第12章 指针和数组184
12.1 指针的算术运算184
12.1.1 指针加上整数185
12.1.2 指针减去整数185
12.1.3 两个指针相减186
12.1.4 指针比较186
12.1.5 指向复合常量的指针186
12.2 指针用于数组处理186
12.3 用数组名作为指针188程序数列反向（改进版）189
12.3.1 数组型实际参数（改进版）189
12.3.2 用指针作为数组名191
12.4 指针和多维数组191
12.4.1 处理多维数组的元素191
12.4.2 处理多维数组的行192
12.4.3 处理多维数组的列192
12.4.4 用多维数组名作为指针192
12.5 C99中的指针和变长数组193
问与答194
练习题195
编程题197

第13章 字符串198
13.1 字符串字面量198
13.1.1 字符串字面量中的转义序列198
13.1.2 延续字符串字面量199
13.1.3 如何存储字符串字面量199
13.1.4 字符串字面量的操作200
13.1.5 字符串字面量与字符常量200
13.2 字符串变量200
13.2.1 初始化字符串变量201
13.2.2 字符数组与字符指针202
13.3 字符串的读和写203
13.3.1 用printf函数和puts函数写字符串203
13.3.2 用scanf函数和gets函数读字符串203
13.3.3 逐个字符读字符串204
13.4 访问字符串中的字符205
13.5 使用C语言的字符串库206
13.5.1 strcpy函数207
13.5.2 strlen函数208
13.5.3 strcat函数208
13.5.4 strcmp函数209程序显示一个月的提醒列表209
13.6 字符串惯用法211
13.6.1 搜索字符串的结尾211
13.6.2 复制字符串213
13.7 字符串数组214
程序核对行星的名字217
问与答218
练习题220
编程题222

第14章 预处理器225
14.1 预处理器的工作原理225
14.2 预处理指令227
14.3 宏定义227
14.3.1 简单的宏227
14.3.2 带参数的宏229
14.3.3 #运算符231
14.3.4 ##运算符231
14.3.5 宏的通用属性232
14.3.6 宏定义中的圆括号233
14.3.7 创建较长的宏233
14.3.8 预定义宏234
14.3.9 C99中新增的预定义宏235
14.3.10 空的宏参数236
14.3.11 参数个数可变的宏236
14.3.12 __func__标识符237
14.4 条件编译237
14.4.1 #if指令和#endif指令238
14.4.2 defined运算符238
14.4.3 #ifdef指令和#ifndef指令239
14.4.4 #elif指令和#else指令239
14.4.5 使用条件编译240
14.5 其他指令240
14.5.1 #error指令240
14.5.2 #line指令241
14.5.3 #pragma指令242
14.5.4 _Pragma运算符242
问与答243
练习题245

第15章 编写大型程序248
15.1 源文件248
15.2 头文件249
15.2.1 #include指令249
15.2.2 共享宏定义和类型定义250
15.2.3 共享函数原型251
15.2.4 共享变量声明252
15.2.5 嵌套包含253
15.2.6 保护头文件253
15.2.7 头文件中的#error指令254
15.3 把程序划分成多个文件254程序文本格式化255
15.4 构建多文件程序260
15.4.1 makefile260
15.4.2 链接期间的错误262
15.4.3 重新构建程序262
15.4.4 在程序外定义宏264
问与答264
练习题265
编程题266

第16章 结构、联合和枚举267
16.1 结构变量267
16.1.1 结构变量的声明267
16.1.2 结构变量的初始化269
16.1.3 指定初始化269
16.1.4 对结构的操作270
16.2 结构类型270
16.2.1 结构标记的声明271
16.2.2 结构类型的定义272
16.2.3 结构作为参数和返回值272
16.2.4 复合字面量273
16.3 嵌套的数组和结构274
16.3.1 嵌套的结构274
16.3.2 结构数组274
16.3.3 结构数组的初始化275程序维护零件数据库275
16.4 联合281
16.4.1 用联合来节省空间282
16.4.2 用联合来构造混合的数据结构284
16.4.3 为联合添加“标记字段”284
16.5 枚举285
16.5.1 枚举标记和类型名286
16.5.2 枚举作为整数286
16.5.3 用枚举声明“标记字段”286
问与答287
练习题289
编程题293

第17章 指针的高级应用294
17.1 动态存储分配294
17.1.1 内存分配函数294
17.1.2 空指针295
17.2 动态分配字符串296
……
第18章 声明 327
第19章 程序设计 345
第20章 底层程序设计 363
第21章 标准库 377
第22章 输入/输出 384
第23章 库对数值和字符数据的支持 419
第24章 错误处理 446
第25章 国际化特性 456
第26章 其他库函数 482
第27章 C99对数学计算的新增支持 503
附录A C语言运算符 524
附录B C99与C89的比较 525
附录C C89与经典C的比较 529
附录D 标准库函数 532
附录E ASCII字符集 569
参考文献 570
索引 573



[ 本帖最后由 tiankai001 于 2013-9-10 13:12 编辑 ]

tiankai001

C和指针


《C和指针 POINTERS ON C》通过对指针的基础知识和高级特性的探讨，帮助程序员把指针的强大功能融入到自己的程序中去。全书共18章，覆盖了数据、语句、操作符和表达式、指针、函数、数组、字符串、结构和联合等几乎所有重要的C编程话题。

我竭尽全力地推荐这本我所见过的最好的C编程入门图书。作者深知读者所需，并为他们打下良好基础。如果你已经开始学习C语言但始终不得要领，不妨试一试这本书。

    ——Francis Glassborow，ACCU主席

    本书提供与C语言编程相关的全面资源和深入讨论，通过对指针的基础知识和高级特性的探讨，帮助程序员把指针的强大功能融入到自己的程序中去。

    ——编辑推荐

《C和指针 POINTERS ON C》提供与C语言编程相关的全面资源和深入讨论。本书通过对指针的基础知识和高级特性的探讨，帮助程序员把指针的强大功能融入到自己的程序中去。
　　全书共18章，覆盖了数据、语句、操作符和表达式、指针、函数、数组、字符串、结构和联合等几乎所有重要的C编程话题。书中给出了很多编程技巧和提示，每章后面有针对性很强的练习，附录部分则给出了部分练习的解答。
　　本书适合C语言初学者和初级c程序员阅读，也可作为计算机专业学生学习c语言的参考。

第1章　快速上手
1.1　简介
1.1.1　空白和注释
1.1.2　预处理指令
1.1.3　main函数
1.1.4　read_column_numbers函数
1.1.5　rearrange函数
1.2　补充说明
1.3　编译
1.4　总结
1.5　警告的总结
1.6　编程提示的总结
1.7　问题
1.8　编程练习
第2章　基本概念
2.1　环境
2.1.1　翻译
2.1.2　执行
2.2　词法规则
2.2.1　字符
2.2.2　注释
2.2.3　自由形式的源代码
2.2.4　标识符
2.2.5　程序的形式
2.3　程序风格
2.4　总结
2.5　警告的总结
2.6　编程提示的总结
2.7　问题
2.8　编程练习
第3章　数据
3.1　基本数据类型
3.1.1　整型家族
3.1.2　浮点类型
3.1.3　指针
3.2　基本声明
3.2.1　初始化
3.2.2　声明简单数组
3.2.3　声明指针
3.2.4　隐式声明
3.3　typedef
3.4　常量
3.5　作用域
3.5.1　代码块作用域
3.5.2　文件作用域
3.5.3　原型作用域
3.5.4　函数作用域
3.6　链接属性
3.7　存储类型
3.8　static关键字
3.9　作用域、存储类型示例
3.10　总结
3.11　警告的总结
3.12　编程提示的总结
3.13　问题
第4章　语句
4.1　空语句
4.2　表达式语句
4.3　代码块
4.4　if语句
4.5　while语句
4.5.1　break和continue语句
4.5.2　while语句的执行过程
4.6　for语句
4.7　do语句
4.8　switch语句
4.8.1　switch中的break语句
4.8.2　default子句
4.8.3　switch语句的执行过程
4.9　goto语句
4.10　总结
4.11　警告的总结
4.12　编程提示的总结
4.13　问题
4.14　编程练习
第5章　操作符和表达式
5.1　操作符
5.1.1　算术操作符
5.1.2　移位操作符
5.1.3　位操作符
5.1.4　赋值
5.1.5　单目操作符
5.1.6　关系操作符
5.1.7　逻辑操作符
5.1.8　条件操作符
5.1.9　逗号操作符
5.1.10　下标引用、函数调用和结构成员
5.2　布尔值
5.3　左值和右值
5.4　表达式求值
5.4.1　隐式类型转换
5.4.2　算术转换
5.4.3　操作符的属性
5.4.4　优先级和求值的顺序
5.5　总结
5.6　警告的总结
5.7　编程提示的总结
5.8　问题
5.9　编程练习
第6章　指针
6.1　内存和地址
6.2　值和类型
6.3　指针变量的内容
6.4　间接访问操作符
6.5　未初始化和非法的指针
6.6　NULL指针
6.7　指针、间接访问和左值
6.8　指针、间接访问和变量
6.9　指针常量
6.10　指针的指针
6.11　指针表达式
6.12　实例
6.13　指针运算
6.13.1　算术运算
6.13.2　关系运算
6.14　总结
6.15　警告的总结
6.16　编程提示的总结
6.17　问题
6.18　编程练习
第7章　函数
7.1　函数定义
7.2　函数声明
7.2.1　原型
7.2.2　函数的缺省认定
7.3　函数的参数
7.4　ADT和黑盒
7.5　递归
7.5.1　追踪递归函数
7.5.2　递归与迭代
7.6　可变参数列表
7.6.1　stdarg宏
7.6.2　可变参数的限制
7.7　总结
7.8　警告的总结
7.9　编程提示的总结
7.10　问题
7.11　编程练习
第8章　数组
8.1　一维数组
8.1.1　数组名
8.1.2　下标引用
8.1.3　指针与下标
8.1.4　指针的效率
8.1.5　数组和指针
8.1.6　作为函数参数的数组名
8.1.7　声明数组参数
8.1.8　初始化
8.1.9　不完整的初始化
8.1.10　自动计算数组长度
8.1.11　字符数组的初始化
8.2　多维数组
8.2.1　存储顺序
8.2.2　数组名
8.2.3　下标
8.2.4　指向数组的指针
8.2.5　作为函数参数的多维数组
8.2.6　初始化
8.2.7　数组长度自动计算
8.3　指针数组
8.4　总结
8.5　警告的总结
8.6　编程提示的总结
8.7　问题
8.8　编程练习
第9章　字符串、字符和字节
9.1　字符串基础
9.2　字符串长度
9.3　不受限制的字符串函数
9.3.1　复制字符串
9.3.2　连接字符串
9.3.3　函数的返回值
9.3.4　字符串比较
9.4　长度受限的字符串函数
9.5　字符串查找基础
9.5.1　查找一个字符
9.5.2　查找任何几个字符
9.5.3　查找一个子串
9.6　高级字符串查找
9.6.1　查找一个字符串前缀
9.6.2　查找标记
9.7　错误信息
9.8　字符操作
9.8.1　字符分类
9.8.2　字符转换
9.9　内存操作
9.10　总结
9.11　警告的总结
9.12　编程提示的总结
9.13　问题
9.14　编程练习
第10章　结构和联合
10.1　结构基础知识
10.1.1　结构声明
10.1.2　结构成员
10.1.3　结构成员的直接访问
10.1.4　结构成员的间接访问
10.1.5　结构的自引用
10.1.6　不完整的声明
10.1.7　结构的初始化
10.2　结构、指针和成员
10.2.1　访问指针
10.2.2　访问结构
10.2.3　访问结构成员
10.2.4　访问嵌套的结构
10.2.5　访问指针成员
10.3　结构的存储分配
10.4　作为函数参数的结构
10.5　位段
10.6　联合
10.6.1　变体记录
10.6.2　联合的初始化
10.7　总结
10.8　警告的总结
10.9　编程提示的总结
10.10　问题
10.11　编程练习
第11章　动态内存分配
11.1　为什么使用动态内存分配
11.2　malloc和free
11.3　calloc和realloc
11.4　使用动态分配的内存
11.5　常见的动态内存错误
11.6　内存分配实例
11.7　总结
11.8　警告的总结
11.9　编程提示的总结
11.10　问题
11.11　编程练习
第12章　使用结构和指针
12.1　链表
12.2　单链表
12.2.1　在单链表中插入
12.2.2　其他链表操作
12.3　双链表
12.3.1　在双链表中插入
12.3.2　其他链表操作
12.4　总结
12.5　警告的总结
12.6　编程提示的总结
12.7　问题
12.8　编程练习
第13章　高级指针话题
13.1　进一步探讨指向指针的指针
13.2　高级声明
13.3　函数指针
13.3.1　回调函数
13.3.2　转移表
13.4　命令行参数
13.4.1　传递命令行参数
13.4.2　处理命令行参数
13.5　字符串常量
13.6　总结
13.7　警告的总结
13.8　编程提示的总结
13.9　问题
13.10　编程练习
第14章　预处理器
14.1　预定义符号
14.2　#define
14.2.1　宏
14.2.2　#define替换
14.2.3　宏与函数
14.2.4　带副作用的宏参数
14.2.5　命名约定
14.2.6　#undef
14.2.7　命令行定义
14.3　条件编译
14.3.1　是否被定义
14.3.2　嵌套指令
14.4　文件包含
14.4.1　函数库文件包含
14.4.2　本地文件包含
14.4.3　嵌套文件包含
14.5　其他指令
14.6　总结
14.7　警告的总结
14.8　编程提示的总结
14.9　问题
14.10　编程练习
第15章　输入/输出函数
15.1　错误报告
15.2　终止执行
15.3　标准I/O函数库
15.4　ANSI I/O概念
15.4.1　流
15.4.2　文件
15.4.3　标准I/O常量
15.5　流I/O总览
15.6　打开流
15.7　关闭流
15.8　字符I/O
15.8.1　字符I/O宏
15.8.2　撤销字符I/O
15.9　未格式化的行I/O
15.10　格式化的行I/O
15.10.1　scanf家族
15.10.2　scanf格式代码
15.10.3　printf家族
15.10.4　printf格式代码
15.11　二进制I/O
15.12　刷新和定位函数
15.13　改变缓冲方式
15.14　流错误函数
15.15　临时文件
15.16　文件操纵函数
15.17　总结
15.18　警告的总结
15.19　编程提示的总结
15.20　问题
15.21　编程练习
第16章　标准函数库
16.1　整型函数
16.1.1　算术
16.1.2　随机数
16.1.3　字符串转换
16.2　浮点型函数
16.2.1　三角函数
16.2.2　双曲函数
16.2.3　对数和指数函数
16.2.4　浮点表示形式
16.2.5　幂
16.2.6　底数、顶数、绝对值和余数
16.2.7　字符串转换
16.3　日期和时间函数
16.3.1　处理器时间
16.3.2　当天时间
16.4　非本地跳转
16.4.1　实例
16.4.2　何时使用非本地跳转
16.5　信号
16.5.1　信号名
16.5.2　处理信号
16.5.3　信号处理函数
16.6　打印可变参数列表
16.7　执行环境
16.7.1　终止执行
16.7.2　断言
16.7.3　环境
16.7.4　执行系统命令
16.7.5　排序和查找
16.8　locale
16.8.1　数值和货币格式
16.8.2　字符串和locale
16.8.3　改变locale的效果
16.9　总结
16.10　警告的总结
16.11　编程提示的总结
16.12　问题
16.13　编程练习
第17章　经典抽象数据类型
17.1　内存分配
17.2　堆栈
17.2.1　堆栈接口
17.2.2　实现堆栈
17.3　队列
17.3.1　队列接口
17.3.2　实现队列
17.4　树
17.4.1　在二叉搜索树中插入
17.4.2　从二叉搜索树删除节点
17.4.3　在二叉搜索树中查找
17.4.4　树的遍历
17.4.5　二叉搜索树接口
17.4.6　实现二叉搜索树
17.5　实现的改进
17.5.1　拥有超过一个的堆栈
17.5.2　拥有超过一种的类型
17.5.3　名字冲突
17.5.4　标准函数库的ADT
17.6　总结
17.7　警告的总结
17.8　编程提示的总结
17.9　问题
17.10　编程练习
第18章　运行时环境
18.1　判断运行时环境
18.1.1　测试程序
18.1.2　静态变量和初始化
18.1.3　堆栈帧
18.1.4　寄存器变量
18.1.5　外部标识符的长度
18.1.6　判断堆栈帧布局
18.1.7　表达式的副作用
18.2　C和汇编语言的接口
18.3　运行时效率
18.4　总结
18.5　警告的总结
18.6　编程提示的总结
18.7　问题
18.8　编程练习
附录　部分问题答案
索引　




[ 本帖最后由 tiankai001 于 2013-9-10 13:18 编辑 ]

tiankai001

C语言大全


内容简介：

本书根据国际著名的计算机程序语言专家Herbert Shchildt的专著翻译。这是一本C语言的百科全书，其中包括C的命令、功能、编程和应用等方面的内容，是集专家及C语言编程人员的多方面专门经验之作。全书共分六大部分，共29章。第一部分详细讨论了关键字、预处理、指令和C语言特性；第二部分详细介绍了新的C99标准，并将C89和C99进行了仔细对比；第三部分详细介绍了C标准程序库；第四部分介绍算法和应用程序；第五部分详细讨论了Windows 2000框架的构造，并用实例讨论了C软件的开发技术；第六部分介绍C解释程序。
本书内容全面，叙述清晰，辅以大量实例与应用示例，为广大PC机用户程序开发人员提供了一部很有价值的工具书。也可作计算机应用人员,有关大专院校师生及PC机软件开发人员的参考书.


目录:

第一部分 C语言基础
第1章 C语言概述
1．1 C语言的简要历史
1．2 C是中级语言
1．3 C是结构化语言
1．4 C是面向程序员的语言
1．5 编译和解释
1．6 C程序的格式
1．7 库和链接
1．8 分别编译
1．9 编译C程序
1．10 C的内存映像
1．11 C与C++
1．12 术语
第2章 C表达式
2．1 基本数据类型
2．2 修饰基本类型
2．3 标识符命名
2．4 变量
2．4．1 定义变量的位置
2．4．2 局部变量
2．4．3 形式参数
2．4．4 全局变量
2．4．5 C语言的四个域
2．5 类型修饰符
2．5．1 const
2．5．2 volatile
2．6 存储类型说明符
2．6．1 extern
2．6．2 static变量
2．6．3 register变量
2．7 变量初始化
2．8 常量
2．8．1 16进制和8进制常量
2．8．2 串常量
2．8．3 反斜线字符常量
2．9 操作符
2．9．1 赋值操作符
2．9．2 赋值中的类型转换
2．9．3 多重赋值
2．9．4 复合赋值
2．9．5 算术操作符
2．9．6 增量和减量
2．9．7 关系和逻辑操作符
2．9．8 位操作符
2．9．9 问号(?)操作符
2．9．10 指针操作符＆和*
2．9．11 编译时操作符sizeof()
2．9．12 逗号(，)操作符
2．9．13 圆点(．)和箭头(→)操作符
2．9．14 []和()操作符
2．9．15 优先级小结
2．10 表达式
2．10．1 求值顺序
2．10．2 表达式中的类型转换
2．10．3 强制类型转换
2．10．4 间隔和括号
第3章 语句
3．1 C的真值和假值
3．2 选择语句
3．2．1 if语句
3．2．2 嵌套if语句
3．2．3 if—else—if梯次
3．2．4 代替if的问号(?)
3．2．5 条件表达式
3．2．6 switch
3．2．7 嵌套switch语句
3．3 重复(Iteration)语句
3．3．1 for循环
3．3．2 for循环的变形
3．3．3 无限循环
3．3．4 无循环体的循环
3．3．5 在for循环中声明变量
3．3．6 while循环
3．3．7 do—while循环
3．4 跳转语句
3．4．1 return语句
3．4．2 goto语句
3．4．3 break语句
3．4．4 exit()函数
3．4．5 continue语句
3．5 表达式语句
3．6 块语句
第4章 数组和串
4．1 一维数组
4．2 指向数组的指针
4．3 向函数传一维数组
4．4 串
4．5 二维数组
4．5．1 字符串数组
4．6 多维数组
4．7 指针的下标操作
4．8 数组初始化
4．8．1 无尺寸数组初始化
4．9 可变长数组
4．10 一担挑游戏
第5章 指针
5. 1 什么是指针
5．2 指针变量
5．3 指针操作符
5．4 指针表达式
5．4．1 指针赋值
5．4．2 指针转换
5．4．3 指针算术操作
5．4．4 指针比较
5．5 指针和数组
5．5．1 指针数组
5．6 多级间址
5．7 指针初始化
5．8 函数指针
5．9 动态分配函数
5．9．1 动态分配的数组
5．10 由restrict修饰的指针
5．11 与指针有关的问题
第6章 函数
6．1 函数的一般形式
6．2 理解函数的作用域规则
6．3 函数的变元
6．3．1 值调用和引用调用
6．3．2 引用调用
6．3．3 用数组调用
6．4 main()的变元argc和argv
6．5 返回语句
6．5．1 从函数中返回
6．5．2 返回值
6．5．3 返回指针
6．5．4 void型函数
6．6 main()的返回值
6．7 递归
6．8 函数原型
6．8．1 老式风格的函数声明
6．8．2 标准的库函数原型
6．9 定义可变长度的参数表
6．10 “隐含的int”规则
6．11 参数声明的老式方法和现代方法
6．12 inline关键字
第7章 结构、联台、枚举和用户定义类型
7．1 结构
7．1．1 存取结构成员
7．1．2 结构赋值
7．2 结构数组
7．2．1 通信录实例
7．3 向函数传递结构
7．3．1 向函数传结构成员
7．3．2 向函数传递全结构
7．4 结构指针
7．4．1 定义结构指针
7．4．2 使用结构指针
7．5 结构中的数组和结构
7．6 联合
7．7 位域
7．8 枚举
7．9 C与G++之间的重要差别
7．10 用sizeof确保可移植性
7．11 typedef
第8章 控制台I／O
8．1 读写字符
8．1．1 getchar()的问题
8．1．2 代替getchar()的函数
8．2 读写串
8．3 格式化控制台I／O
8．4 printf
8．4．1 打印字符和串
8．4．2 打印数值
8．4．3 显示地址
8．4．4 格式说明符％n
8．4．5 格式修饰符
8．4．6 最小域宽说明符
8．4．7 精度说明符
8．4．8 对齐输出
8．4．9 处理其他数据类型
8．4．10 修饰符*和#
8．5 scanf()
8．5．1 格式说明符
8．5．2 输入数值
8．5．3 输入无符号整数
8．5．4 用scanf()读单字符
8．5．5 用scanf()读串
8．5．6 输入地址
8．5．7 格式符％n
8．5．8 使用扫描集合
8．5．9 过滤多余空白符
8．5．10 控制串中的非空白符
8．5．11 必须向scanf()传地址
8．5．12 格式修饰符
8．5．13 忽略输入
第9章 文件I/O
9．1 C与C++I/O
9．2 标准C的I/O和UNIX C的I/O
9．3 流和文件
9．4 流
9．4．1 文本流
9．4．2 二进制流
9．5 文件
9．6 文件系统基础
9．6．1 文件指针
9．6．2 打开文件
9．6．3 关闭文件
9．6．4 写字符
9．6．5 读字符
9．6．6 使用fopen()、getc()、putc()和fclose()
9．6．7 使用feof()
9．6．8 用fputs()和fgets()处理串
9．6．9 rewind()
9．6．10 ferror()
9．6．11 删除文件
9．6．12 对流清仓
9．7 fread()和fwrite()
9．7．1 使用fread()和fwrite()
9．7．2 通信录实例
9．8 fseek ()和随机存取I／O
9．9 fprintf()和fscanf()
9．10 标准流
9．10．1 控制台I/O的连接
9．10．2 用freopen()重定向标准流
第10章 预处理程序和注释
10．1 预处理程序
10．2 #define
10．2．1 定义类函数宏
10．3 #error
10．4 #include
10．5 条件编译指令
10．5．1 #if、#else、#elif和#endif
10．5．2 #ifdef 和#ifndef
10．6 #undef
10．7 使用defined
10．8 #line
10．9 #pragma
10．10 预处理操作符#和##
10．11 预定义宏
10．12 注释
10．12．1 单行注释
第二部分 C99标准
第11章 C99
11．1 C89与C99概述
11．1．1 增加的特性
11．1．2 删除的特性
11．1．3 修改的特性
11．2 由restrict修饰的指针
11．3 inline
11．4 新的内置数据类型
11．4．1 _Bool
11．4．2 _Complex和_Imaginary
11．4．3 long long int类型
11．5 对数组的增强
11．5．1 变长数组
11．5．2 类型修饰符在数组声明中的应用
11．6 单行注释
11．7 分散代码和声明
11．8 预处理程序的修改
11．8．1 变元表
11．8．2 _Pragma操作符
11．8．3 内置的编译指令(Pragmas)
11．8．4 增加的内置宏
11．9 在for循环中声明变量
11．10 复合赋值
11．11 柔性数组结构成员
11．12 指定的初始化符
11．13 printf()和scanf()函数系列的新增内容
11．14 C99中的新库
11．15 __func__预定义标识符
11．16 放宽的转换限制
11．17 不再支持隐含的int
11．18 删除了隐含的函数声明
11．19 对返回值的约束
11．20 扩展的整数类型
11．2l 对整数类型提升规则的修改
第三部分 C标准库
第12章 链接、库和头部
12．1 链接程序
12．1．1 分别编译
12．1．2 可重定位代码与绝对代码
12．1．3 覆盖链接
12．1．4 DLL链接
12．2 C标准库
12．2．1 库和目标码文件
12．3 头部
12．3．1 头部文件中的宏
12．4 重新定义库函数
第13章 I/O函数
13．1 clearerr
13．1．1 例子
13．1．2 有关函数
13．2 fclose
13．2．1 例子
13．2．2 有关函数
13．3 feof
13．3．1 例子
13．3．2 有关函数
13．4 ferror
13．4．1 例子
13．4．2 有关函数
13．5 fflush
13．5．1 例子
13．5．2 有关函数
13．6 fgetc
13．6．1 例子
13．6．2 有关函数
13．7 fgetpos
13．7．1 例子
13．7．2 有关函数
13．8 fgets
13．8．1 例子
13．8．2 有关函数
13．9 fopen
13．9．1 例子
13．9．2 有关函数
13．10 fprintf
13．10．1 例子
13．10．2 有关函数
13．11 fputc
13．11．1 例子
13．11．2 有关函数
13．12 fputs
13．12．1 例子
13．12．2 有关函数
13．13 fread
13．13．1 例子
13．13．2 有关函数
13．14 freopen
13．14．1 例子
13．14．2 有关函数
13．15 fscanf
13．15．1 例子
13．15．2 有关函数
13．16 fseek
13．16．1 例子
13．16．2 有关函数
13．17 fsetpos
13．17．1 例子
13．17．2 有关函数
13．18 ftell
13．18．1 例子
13．18．2 有关函数
13．19 fwrite
13．19．1 例子
13．19．2 有关函数
13．20 getc
13．2D．1 例子
13．20．2 有关函数
13．21 getchar
13．21．1 例子
13．21．2 有关函数
13．22 gets
13．22．1 例子
13．22．2 有关函数
13．23 Perror
13．23．1 例子
13．24 printf
13．24．1 C99为printf()增加的格式修饰符
13．24．2 例子
13．24．3 有关函数
13．25 putc
13．25．1 例子
13．25．2 有关函数
13．26 putchar
13．26．1 例子
13．26．2 有关函数
13．27 puts
13．27．1 例子
13．27．2 有关函数
13．28 remove
13．28．1 例子
13．28．2 有关函数
13．29 rename
13．29．1 例子
13．29．2 有关函数
13．30 rewind
13．30．1 例子
13．30．2 有关函数
13．31 scanf
13．31．1 C99为scanf()增加的格式修饰符
13．31．2 例子
13．31．3 有关函数
13．32 setbuf
13．32．1 例子
13．32．2 有关函数
13．33 setvbuf
13．33．1 例子
13．33．2 有关函数
13．34 snprintf
13．34．1 有关函数
13．35 sprintf
13．35．1 例子
13．35．2 有关函数
13．36 sscanf
13．36．1 例子
13．36．2 有关函数
13．37 tmpfile
13．37．1 例子
13．37．2 有关函数
13．38 tmpnam
13．38．1 例子
13．38．2 有关函数
13．39 ungetc
13．39．1 例子
13．39．2 有关函数
13．40 vpirintf、vfprintf、vsprintf及vsnprintf
13．40．1 例子
13．40．2 有关函数
13．41 vscanf、vfscanf及vsscanf
13．41．1 有关函数
第14章 串和字符函数
14．1 isalnum
14．1．1 例子
14．1．2 有关函数
14．2 isalpha
14．2．1 例子
14．2．2 有关函数
14．3 isblank
14．3．1 例子
14．3．2 有关函数
14．4 iscntrl
14．4．1 例子
14．4．2 有关函数
14．5 isdigit
14．5．1 例子
14．5．2 有关函数
14．6 isgraph
14．6．1 例子
14．6．2 有关函数
14．7 islower
14．7．1 例子
14．7．2 有关函数
14．8 isprint
14．8．1 例子
14．8．2 有关函数
14．9 ispunct
14．9．1 例子
14．9．2 有关函数
14．10 isspace
14．10．1 例子
14．10．2 有关函数
14．11 isupper
14．11．1 例子
14．11．2 有关函数
14．12 isxdigit
14．12．1 例子
14．12．2 有关函数
14．13 memchr
14．13．1 例子
14．13．2 有关函数
14．14 memcmp
14．14．1 例子
14．14．2 有关函数
14．15 emecpy
14．15．1 例子
14．15．2 有关函数
14．16 memmove
14．16．1 例子
14．16．2 有关函数
14．17 memset
14．17．1 例子
14．17．2 有关函数
14．18 strcat
14．18．1 例子
14．18．2 有关函数
14．19 strchr
14．19．1 例子
14．19．2 有关函数
14．20 strcmp
14．20．1 例子
14．20．2 有关函数
14．21 strcoll
14．21．1 例子
14．21．2 有关函数
14．22 strcpy
14．22．1 例子
14．22．2 有关函数
14．23 strcspn
14．23．1 例子
14．23．2 有关函数
14．24 strerror
14．24．1 例子
14．25 strlen
14．25．1 例子
14．25．2 有关函数
14．26 strncat
14．26．1 例子
14．26．2 有关函数
14．27 strncmp
14．27．1 例子
14．27．2 有关函数
14．28 strncpy
14．28．1 例子
14．28．2 有关函数
14．29 strpbrk
14．29．1 例子
14. 29．2 有关函数
14．30 strrchr
14．30．1 例子
14．30．2 有关函数
14．31 strspn
14．31．1 例子
14．31．2 有关函数
14．32 strstr
14．32．1 例子
14．32．2 有关函数
14．33 strtok
14．33．1 例子
14．33．2 有关函数
14．34 strxfrm
14．34．1 例子
14．34．2 有关函数
14．35 tolower
14．35．1 例子
14．35．2 有关函数
14．36 toupper
14．36．1 例子
14．36．2 有关函数
第15章 数学函数
15．1 acos
15．1．1 例子
15．1．2 有关函数
15．2 acosh
15．2．1 有关函数
15．3 asin
15．3．1 例子
15．3．2 有关函数
15．4 asinh
15．4．1 有关函数
15．5 atan
15．5．1 例子
15．5．2 有关函数
15．6 atanh
15．6．1 有关函数
15．7 atan2
15．7．1 例子
15．7．2 有关函数
15．8 cbrt
15．8．1 例子
15．8．2 有关函数
15．9 ceil
15．9．1 例子
15．9．2 有关函数
15．10 copysign
15．10．1 有关函数
15．11 cos
15．11．1 例子
15．11．2 有关函数
15. 12 cosh
15．12．1 例子
15．12．2 有关函数
15．1 erf
15．13．1 有关函数
15．14 erfc
15．14．1 有关函数
15．15 exp
15．15．1 例子
15．15．2 有关函数
15．16 exp2
15．16．1 有关函数
15．17 expml
15．17．1 有关函数
15．18 fabs
15．18．1 例子
15. 18. 2 有关函数
15．19 fdim
15．19．1 有关函数
15．20 floor
15．20．1 例子
15．20．2 有关函数
15．21 fma
15．21．1 有关函数
15．22 fmax
15．22．1 有关函数
15．23 fmin
15．23．1 有关函数
15．24 fmod
15．24．1 例子
15．24．2 有关函数
15．25 frexp
15．25. 1 例子
15．25．2 有关函数
15．26 hypot
15．26．1 有关函数
15．27 ilogb
15．27．1 有关函数
15．28 ldexp
15．28．1 例子
15．28．2 有关函数
15．29 Imamma
15．29．1 有关函数
15．30 llrint
15．30．1 有关函数
15．31 llround
15．31．1 有关函数
15．32 log
15．32．1 例子
15．32．2 有关函数
15．33 loglp
15．33．1 有关函数
15．34 log10
15．34．1 例子
15．34．2 有关函数
15．35 log2
15．35．1 有关函数
15．36 logb
15. 36. 1 有关函数
15．37 lrint
15．37．1 有关函数
15．38 lround
15．38. 1 有关函数
15．39 modef
15．39. 1 例子
15．39. 2 有关函数
15．40 nan
15．40．1 有关函数
15．41 nearbyint
15．41．1 有关函数
15．42 nextafter
15. 42．1 有关函数
15．43 nexttoward
15．43．1 有关函数
15．44 pow
15．44．1 例子
15．44．2 有关函数
15．45 remainder
15．45. 1 有关函数
15．46 remquo
15．46．1 有关函数
15．47 rint
15．47．1 有关函数
15．48 round
15．48．1 有关函数
15．49 scalbln
15．49．1 有关函数
15．50 scalbn
15．50．1 有关函数
15．51 sin
15．51．1 例子
15．51．2 有关函数
15．52 sinh
15．52．1 例子
15．52．2 有关函数
15．53 sqrt
15．53．1 例子
15．53．2 有关函数
15．54 tan
15．54．1 例子
15．54．2 有关函数
15．55 tanh
15．55．1 例子
15．55．2 有关函数
15．56 tgamma
15．56．1 有关函数
15．57 trunc
15．57．1 有关函数
第16章 时间、日期和本地化函数
16．1 asctime
16．1. 1 例子
16．1．2 有关函数
16．2 clock
16．2．1 例子
16．2．2 有关函数
16．3 ctime
16．3．1 例子
16．3．2 有关函数
16．4 difftime
16．4．1 例子
16．4．2 有关函数
16．5 gmtime
16．5．1 例子
16．5．2 有关函数
16．6 localeconv
16．6．1 例子
16．6．2 有关函数
16．7 localtime
16．7．1 例子
16．7．2 有关函数
16．8 mktime
16．8．1 例子
16．8．2 有关函数
16．9 setlocale
16．9．1 例子
16．9．2 有关函数
16．10 strftime
16．10．1 例子
16．10．2 有关函数
16．11 time
16．11．1 例子
16．11．2 有关函数
第17章 动态分配函数
17．10 calloc
17．1．1 有关函数
17．2 free
17．2．1 例子
17．2．2 有关函数
17．3 malloc
17．3．1 例子
17．3．2 有关函数
17．4 realloc
17．4．1 例子
17．4．2 有关函数
第18章 工具函数
18．1 abort
18．1．1 例子
18．1．2 有关函数
18．2 abs
18．2．1 例子
18．2．2 有关函数
18．3 assert
18．3．1 例子
18．3．2 有关函数
18．4 atexit
18．4．1 例子
18．4．2 有关函数
18．5 atof
18．5．1 例子
18．5．2 有关函数
18．6 atoi
18．6．1 例子
18．6．2 有关函数
18．7 atol
18．7．1 例子
18．7．2 有关函数
18．8 atoll
18．8．1 有关函数
18．9 bsearch
18．9．1 例子
18．9．2 有关函数
18．10 div
18．10．1 例子
18．10．2 有关函数
18．11 exit
18．11．1 例子

[ 本帖最后由 tiankai001 于 2013-9-10 22:52 编辑 ]

tiankai001

[C语言入门经典(第四版)].（美）霍顿.扫描版

尊敬的读者：
　　C语言是一种非常优秀的程序设计的入门语言。它比其他大部分语言都简洁易学，所以在开始使用C语言编写真正的应用程序之前并不需要学习太多语法。C语言也是功能相当强大的语言，很多操作系统都是用C语言编写的。大多数计算机环境都支持C语言，因此当你学会了C语言后，你将有能力在各种环境下进行程序设计。
　　本书的目标是使你在C语言程序设计方面由一位初学者成为一位称职的程序员。书中包含了C语言的全部基础知识，并将教会你如何进行程序设计。除了本书之外，你需要的东西只有一样，那就是一个得到广泛支持的免费的或者商业的标准C编译器，有了它即可开始编写实际的C程序了。
　　本书从第一个编程原理开始，使用各种程序示例解释C语言的所有元素，不要求你之前拥有任何编程知识。通过编写能够运行的完整C应用程序，在实际的环境中运用所学的知识，可帮助你提高自己的程序设计能力。你也可以在创建和执行自己的程序示例的过程中获得自信。
　　学习C语言也有一定的难度，但是我确信你会感到乐趣无穷，也会发现自己劳有所获。只要你有热情和信心读完本书，你将会掌握大量有价值的知识。从此，你将步入C程序设计的殿堂，开始自己的C程序开发之旅。


《C语言入门经典(第4版)》的目标是使你在C语言程序设计方面由一位初学者成为一位称职的程序员。读者基本不需要具备任何编程知识，即可通过《C语言入门经典(第4版)》从头开始编写自己的C程序。研读《C语言入门经典(第4版)》，你就可以成为一位称职的C语言程序员。从许多方面来说，C语言都是学习程序设计的理想起步语言。C语言很简洁，因此无须学习大量的语法，就能够开始编写真正的应用程序。除了简明易学外，它还是一种功能非常强大的语言，至今仍被专业人士广泛使用。C语言的强大之处主要体现在，它能够进行各种层次的程序设计，从硬件设备驱动程序和操作系统组件到大规模的应用程序，都能胜任。事实上，任何计算机都支持C语言编译器，因此，当我们学会了C语言，就可以在任何环境下进行程序设计。最后一点，掌握了C语言，就为理解面向对象的C++语言奠定了良好的基础。


第1章  C语言编程
1.1  创建C程序
1.1.1  编辑
1.1.2  编译
1.1.3  链接
1.1.4  执行
1.2  创建第一个程序
1.3  编辑第一个程序
1.4  处理错误
1.5  剖析一个简单的程序
1.5.1  注释
1.5.2  预处理指令
1.5.3  定义main()函数
1.5.4  关键字
1.5.5  函数体
1.5.6  输出信息
1.5.7  参数
1.5.8  控制符
1.6  用C语言开发程序
1.6.1  了解问题
1.6.2  详细设计
1.6.3  实施
1.6.4  测试
1.7  函数及模块化编程
1.8  常见错误
1.9  要点
1.10  小结
1.11  习题
第2章  编程初步
2.1  计算机的内存
2.2  什么是变量
2.3  存储数值的变量
2.3.1  整数变量
2.3.2  变量的命名
2.3.3  变量的使用
2.3.4  变量的初始化
2.3.5  算术语句
2.4  变量与内存
2.5  整数变量类型
2.5.1  无符号的整数类型
2.5.2  使用整数类型
2.5.3  指定整数常量
2.6  浮点数
2.7  浮点数变量
2.8  使用浮点数完成除法运算
2.8.1  控制小数位数
2.8.2  控制输出的字段宽度
2.9  较复杂的表达式
2.10  定义常量
2.10.1  极限值
2.10.2  sizeof运算符
2.11  选择正确的类型
2.12  强制类型转换
2.12.1  自动转换类型
2.12.2  隐式类型转换的规则
2.12.3  赋值语句中的隐式类型转换
2.13  再谈数值数据类型
2.13.1  字符类型
2.13.2  字符的输入输出
2.13.3  宽字符类型
2.13.4  枚举
2.13.5  存储布尔值的变量
2.13.6  复数类型
2.14  赋值操作的op=形式
2.15  数学函数
2.16  设计一个程序
2.16.1  问题
2.16.2  分析
2.16.3  解决方案
2.17  小结
2.18  练习
第3章  条件判断
3.1  判断过程
3.1.1  算术比较
3.1.2  涉及关系运算符的表达式
3.1.3  基本的if语句
3.1.4  扩展if语句：if-else
3.1.5  在if语句中使用代码块
3.1.6  嵌套的if语句
3.1.7  更多的关系运算符
3.1.8  逻辑运算符
3.1.9  条件运算符
3.1.10  运算符的优先级
3.2  多项选择问题
3.2.1  给多项选择使用else-if语句
3.2.2  switch语句
3.2.3  goto语句
3.3  按位运算符
3.3.1  按位运算符的op=用法
3.3.2  使用按位运算符
3.4  设计程序
3.4.1  问题
3.4.2  分析
3.4.3  解决方案
3.5  小结
3.6  练习
第4章  循环
4.1  循环
4.2  递增和递减运算符
4.3  for循环
4.4  for循环的一般语法
4.5  再谈递增和递减运算符
4.5.1  递增运算符
4.5.2  递增运算符的前置和后置形式
4.5.3  递减运算符
4.6  再论for循环
4.6.1  修改for循环变量
4.6.2  没有参数的for循环
4.6.3  循环内的break语句
4.6.4  使用for循环限制输入
4.6.5  生成伪随机整数
4.6.6  再谈循环控制选项
4.6.7  浮点类型的循环控制变量
4.7  while循环
4.8  嵌套循环
4.9  嵌套循环和goto语句
4.10  do-while循环
4.11  continue语句
4.12  设计程序
4.12.1  问题
4.12.2  分析
4.12.3  解决方案
4.13  小结
4.14  习题
第5章  数组
5.1  数组简介
5.1.1  不用数组的程序
5.1.2  什么是数组
5.1.3  使用数组
5.2  内存
5.3  数组和地址
5.4  数组的初始化
5.5  确定数组的大小
5.6  多维数组
5.7  多维数组的初始化
5.8  设计一个程序
5.8.1  问题
5.8.2  分析
5.8.3  解决方案
5.9  小结
5.10  习题
第6章  字符串和文本的应用
6.1  什么是字符串
6.2  处理字符串和文本的方法
6.3  字符串操作
6.3.1  连接字符串
6.3.2  字符串数组
6.4  字符串库函数
6.4.1  使用库函数复制字符串
6.4.2  使用库函数确定字符串的长度
6.4.3  使用库函数连接字符串
6.4.4  比较字符串
6.4.5  搜索字符串
6.5  分析和转换字符串
6.5.1  转换字符
6.5.2  将字符串转换成数值
6.7  使用宽字符串
6.8  设计一个程序
6.8.1  问题
6.8.2  分析
6.8.3  解决方案
6.9  小结
6.10  习题
第7章  指针
7.1  指针初探
7.1.1  声明指针
7.1.2  通过指针访问值
7.1.3  使用指针
7.1.4  指向常量的指针
7.1.5  常量指针
7.1.6  指针的命名
7.2  数组和指针
7.3  多维数组
7.3.1  多维数组和指针
7.3.2  访问数组元素
7.4  内存的使用
7.4.1  动态内存分配：malloc()函数
7.4.2  分配内存时使用sizeof运算符
7.4.3  用calloc()函数分配内存
7.4.4  释放动态分配的内存
7.4.5  重新分配内存
7.5  使用指针处理字符串
7.5.1  更多地控制字符串输入
7.5.2  使用指针数组
7.6  设计程序
7.6.1  问题
7.6.2  分析
7.6.3  解决方案
7.7  小结
7.8  习题
第8章  程序的结构
8.1  程序的结构
8.1.1  变量的作用域和生存期
8.1.2  变量的作用域和函数
8.2  函数
8.2.1  定义函数
8.2.2  return语句
8.3  按值传递机制
8.4  函数声明
8.5  指针用作参数和返回值
8.5.1  常量参数
8.5.2  从函数中返回指针值
8.5.3  在函数中递增指针
8.6  小结
8.7  习题
第9章  函数再探
9.1  函数指针
9.1.1  声明函数指针
9.1.2  通过函数指针调用函数
9.1.3  函数指针数组
9.1.4  作为变元的函数指针
9.2  函数中的变量
9.2.1  静态变量：函数内部的追踪
9.2.2  在函数之间共享变量
9.3  调用自己的函数：递归
9.4  变元个数可变的函数
9.4.1  复制va_list
9.4.2  长度可变的变元列表的基本规则
9.5  main()函数
9.6  结束程序
9.7  函数库：头文件
9.8  提高性能
9.8.1  内联声明函数
9.8.2  使用restrict关键字
9.9  设计程序
9.9.1  问题
9.9.2  分析
9.9.3  解决方案
9.10  小结
9.11  习题
第10章  基本输入和输出操作
10.1  输入和输出流
10.2  标准流
10.3  键盘输入
10.3.1  格式化键盘输入
10.3.2  输入格式控制字符串
10.3.3  输入格式字符串中的字符
10.3.4  输入浮点数的各种变化
10.3.5  读取十六进制和八进制值
10.3.6  用scanf()读取字符
10.3.7  scanf()的陷阱
10.3.8  从键盘上输入字符串
10.3.9  键盘的非格式化输入
10.4  屏幕输出
10.4.1  使用printf()格式输出到屏幕
10.4.2  转义序列
10.4.3  整数输出
10.4.4  输出浮点数
10.4.5  字符输出
10.5  其他输出函数
10.5.1  屏幕的非格式化输出
10.5.2  数组的格式化输出
10.5.3  数组的格式化输入
10.6  打印机输出
10.7  小结
10.8  习题
第11章  结构化数据
11.1  数据结构：使用struct
11.1.1  定义结构类型和结构变量
11.1.2  访问结构成员
11.1.3  未命名的结构
11.1.4  结构数组
11.1.5  表达式中的结构
11.1.6  结构指针
11.1.7  为结构动态分配内存
11.2  再探结构成员
11.2.1  将一个结构作为另一个结构的成员
11.2.2  声明结构中的结构
11.2.3  将结构指针用作结构成员
11.2.4  双向链表
11.2.5  结构中的位字段
11.3  结构与函数
11.3.1  结构作为函数的变元
11.3.2  结构指针作为函数变元
11.3.3  作为函数返回值的结构
11.3.4  修改程序
11.3.5  二叉树
11.4  共享内存
11.4.1  联合
11.4.2  联合指针
11.4.3  联合的初始化
11.4.4  联合中的结构成员
11.5  定义自己的数据类型
11.5.1  结构与类型定义(typedef)功能
11.5.2  使用typedef简化代码
11.6  设计程序
11.6.1  问题
11.6.2  分析
11.6.3  解决方案
11.7  小结
11.8  习题
第12章  处理文件
12.1  文件的概念
12.1.1  文件中的位置
12.1.2  文件流
12.2  文件访问
12.2.1  打开文件
12.2.2  文件重命名
12.2.3  关闭文件
12.2.4  删除文件
12.3  写入文本文件
12.4  读取文本文件
12.5  将字符串写入文本文件
12.6  从文本文件中读入字符串
12.7  格式化文件的输入输出
12.7.1  格式化文件输出
12.7.2  格式化文件输入
12.8  错误处理
12.9  再探文本文件操作模式
12.10  二进制文件的输入输出
12.10.1  指定二进制模式
12.10.2  写入二进制文件
12.10.3  读取二进制文件
12.11  在文件中移动
12.11.1  文件定位操作
12.11.2  找出我们在文件中的位置
12.11.3  在文件中设定位置
12.12  使用临时文件
12.12.1  创建临时文件
12.12.2  创建唯一的文件名
12.13  更新二进制文件
12.13.1  修改文件的内容
12.13.2  从键盘读取记录
12.13.3  将记录写入文件
12.13.4  从文件中读取记录
12.13.5  写入文件
12.13.6  列出文件内容
12.13.7  更新已有的文件内容
12.14  文件打开模式小结
12.15  设计程序
12.15.1  问题
12.15.2  分析
12.15.3  解决方案
12.16  小结
12.17  习题
第13章  支持功能
13.1  预处理
13.1.1  在程序中包含头文件
13.1.2  外部变量及函数
13.1.3  替换程序源代码
13.1.4  宏替换
13.1.5  看起来像函数的宏
13.1.6  多行上的预处理指令
13.1.7  字符串作为宏参数
13.1.8  结合两个宏展开式的结果
13.2  预处理器逻辑指令
13.2.1  条件编译
13.2.2  测试指定值的指令
13.2.3  多项选择
13.2.4  标准预处理宏
13.3  调试方法
13.3.1  集成的调试器
13.3.2  调试阶段的预处理器
13.3.3  使用assert()宏
13.4  其他库函数
13.4.1  日期和时间函数库
13.4.2  获取日期
13.5  小结
13.6  习题
附录A  计算机中的数学知识
附录B  ASCII字符代码定义
附录C  C语言中的保留字
附录D  输入输出格式指定符   

[ 本帖最后由 tiankai001 于 2013-9-10 22:56 编辑 ]

tiankai001

你必须知道的C语言问题

全球C语言程序员集体智慧的结晶
　　Amazon全五星图书
　　权威解答495个最常遇到的C语言问题
　　C是一门简洁精妙的语言，掌握基本语法容易，真正能够自如运用，就不那么简单了。你难免会遇到各种各样的问题，有些可能让你百思不得其解，甚至翻遍图书馆，也找不到问题的答案。
　　《你必须知道的495个C语言问题》的出版填补了这一空白。书中内容是世界各地的C语言用户多年来在新闻组comp.1ang.c中讨论的成果。作者在网络版CFAQ列表的基础上进行了大幅度的扩充和丰富，结合代码示例，权威而且详细深入地解答了实际学习和工作中最常遇到的495个C语言问题，涵盖了初始化、数组、指针、字符串、内存分配、库函数、C预处理器等各个方面的主题。许多知识点的阐述都是其他资料中所没有的，弥足珍贵。
　　涵盖C99标准
　　“本书是Summit以及C FAQ在线列表的许多参与者多年心血的结晶，是C语言界最为珍贵的财富之一。我向所有C语言程序员推荐本书。”.
　　——Francis Glassborow，著名C／C++专家，ACCU（C／C++用户协会）前主席
　　“本书清晰地阐明了Kernighan与Ritchie的The C Programming Language一书中许多简略的地方，而且精彩地总结了C语言编程实践，强烈推荐！”
　　——Yechiel M.Kimchi，以色列理工学院


本书以问答的形式组织内容，讨论了学习或使用C语言的过程中经常遇到的一些问题。书中列出了C用户经常问的400多个经典问题，涵盖了初始化、数组、指针、字符串、内存分配、库函数、C预处理器等各个方面的主题，并分别给出了解答，而且结合代码示例阐明要点。
　　本书结构清晰，讲解透彻，是各高校相关专业C语言课程很好的教学参考书，也是各层次C程序员的优秀实践指南。


第1章 声明和初始化
基本类型
1.1 我该如何决定使用哪种整数类型？
1.2 为什么不精确定义标准类型的大小？
1.3 因为C语言没有精确定义类型的大小，所以我一般都用typedef定义int16和int32。然后根据实际的机器环境把它们定义为int、short、long等类型。这样看来，所有的问题都解决了，是吗？
1.4 新的64位机上的64位类型是什么样的？
指针声明
1.5 这样的声明有什么问题？char *p1， p2; 我在使用p2的时候报错了。
1.6 我想声明一个指针，并为它分配一些空间，但却不行。这样的代码有什么问题？char *p; *p=malloc（10）;
声明风格
1.7 怎样声明和定义全局变量和函数最好？
1.8 如何在C中实现不透明（抽象）数据类型？
1.9 如何生成“半全局变量”，就是那种只能被部分源文件中的部分函数访问的变量？
存储类型
1.10 同一个静态（static）函数或变量的所有声明都必须包含static存储类型吗？
1.11 extern在函数声明中是什么意思？
1.12 关键字auto到底有什么用途？
类型定义（typedef）
1.13 对于用户定义类型，typedef 和#define有什么区别？
1.14 我似乎不能成功定义一个链表。我试过typedef struct{char *item; NODEPTR next;}* NODEPTR; 但是编译器报了错误信息。难道在C语言中结构不能包含指向自己的指针吗？
1.15 如何定义一对相互引用的结构？
1.16 Struct{ } x1;和typedef struct{ } x2; 这两个声明有什么区别？
1.17 “typedef int（*funcptr）（）;”是什么意思？
const 限定词
1.18 我有这样一组声明：typedef char *charp; const charp p; 为什么是p而不是它指向的字符为const？
1.19 为什么不能像下面这样在初始式和数组维度值中使用const值？const int n=5; int a[n];
1.20 const char *p、char const *p和char *const p有什么区别？
复杂的声明
1.21 怎样建立和理解非常复杂的声明？例如定义一个包含N个指向返回指向字符的指针的函数的指针的数组？
1.22 如何声明返回指向同类型函数的指针的函数？我在设计一个状态机，用函数表示每种状态，每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数，返回的指针指向的又是返回指针的函数，如此往复，以至无穷。
数组大小
1.23 能否声明和传入数组大小一致的局部数组，或者由其他参数指定大小的参数数组？
1.24 我在一个文件中定义了一个extern数组，然后在另一个文件中使用，为什么sizeof取不到数组的大小？
声明问题
1.25 函数只定义了一次，调用了一次，但编译器提示非法重声明了。
1.26 main的正确定义是什么？void main正确吗？
1.27 我的编译器总在报函数原型不匹配的错误，可我觉得没什么问题。这是为什么？
1.28 文件中的第一个声明就报出奇怪的语法错误，可我看没什么问题。这是为什么？
1.29 为什么我的编译器不允许我定义大数组，如double array[256][256]？
命名空间
1.30 如何判断哪些标识符可以使用，哪些被保留了？
初始化
1.31 对于没有显式初始化的变量的初始值可以作怎样的假定？如果一个全局变量初始值为“零”，它可否作为空指针或浮点零？
1.32 下面的代码为什么不能编译？ intf（）{char a[]="Hello， world!";}
1.33 下面的初始化有什么问题？编译器提示“invalid initializers ”或其他信息。char *p=malloc（10）;
1.34 char a[]= "string literal";和char *p="string literal"; 初始化有什么区别？当我向p 赋值的时候，我的程序崩溃了。
1.35 char a{[3]}= "abc"; 是否合法？
1.36 我总算弄清楚函数指针的声明方法了，但怎样才能初始化呢？
1.37 能够初始化联合吗？

第2章 结构、联合和枚举
结构声明
2.1 struct x1{ };和typedef struct{ }x2; 有什么不同？
2.2 这样的代码为什么不对？struct x{ }; x thestruct;
2.3 结构可以包含指向自己的指针吗？
2.4 在C语言中用什么方法实现抽象数据类型最好？
2.5 在C语言中是否有模拟继承等面向对象程序设计特性的好方法？
2.6 为什么声明extern f（struct x *p）; 给我报了一个晦涩难懂的警告信息？
2.7 我遇到这样声明结构的代码：struct name {int namelen; char namestr[1];};然后又使用一些内存分配技巧使namestr数组用起来好像有多个元素，namelen记录了元素个数。它是怎样工作的？这样是合法的和可移植的吗？
2.8 我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1却明确说明不能这样做？
2.9 为什么不能用内建的==和!=操作符比较结构？
2.10 结构传递和返回是如何实现的？
2.11 如何向接受结构参数的函数传入常量值？怎样创建无名的中间的常量结构值？
2.12 怎样从/向数据文件读/写结构？
结构填充
2.13 为什么我的编译器在结构中留下了空洞？这导致空间浪费而且无法与外部数据文件进行“二进制”读写。能否关掉填充，或者控制结构域的对齐方式？
2.14 为什么sizeof返回的值大于结构大小的期望值，是不是尾部有填充？
2.15 如何确定域在结构中的字节偏移量？
2.16 怎样在运行时用名字访问结构中的域？
2.17 C语言中有和Pascal的with等价的语句吗？
2.18 既然数组名可以用作数组的基地址，为什么对结构不能这样？
2.19 程序运行正确，但退出时却“core dump ”（核心转储）了，怎么回事？
联合
2.20 结构和联合有什么区别？
2.21 有办法初始化联合吗？
2.22 有没有一种自动方法来跟踪联合的哪个域在使用？
枚举
2.23 枚举和一组预处理的#define有什么不同？
2.24 枚举可移植吗？
2.25 有什么显示枚举值符号的容易方法吗？
位域
2.26 一些结构声明中的这些冒号和数字是什么意思？
2.27 为什么人们那么喜欢用显式的掩码和位操作而不直接声明位域？

第3章 表达式
求值顺序
3.1 为什么这样的代码不行？a= i++;
3.2 使用我的编译器，下面的代码int i= 7; printf（"%d\n"， i++ * i++）; 打印出49。不管按什么顺序计算，难道不该是56吗？
3.3 对于代码int i=3; i=i++; 不同编译器给出不同的i值，有的为3，有的为4，哪个是正确的？
3.4 有这样一个巧妙的表达式：a^= b^= a^= b; 它不需要临时变量就可以交换a和b的值。
3.5 可否用显式括号来强制执行我所需要的计算顺序并控制相关的副作用？就算括号不行，操作符优先级是否能够控制计算顺序呢？
3.6 可是&&和||操作符呢？我看到过类似while（（c = getchar（）） != EOF && c != \n）的代码
3.7 是否可以安全地认为，一旦&&和||左边的表达式已经决定了整个表达式的结果，则右边的表达式不会被求值？
3.8 为什么表达式printf（"%d %d"， f1（）， f2（））; 先调用了f2？我觉得逗号表达式应该确保从左到右的求值顺序。
3.9 怎样才能理解复杂表达式并避免写出未定义的表达式？“序列点”是什么？
3.10 在a = i++;中，如果不关心a[]的哪一个分量会被写入，这段代码就没有问题，i也的确会增加1，对吗？
3.11 人们总是说i=i++的行为是未定义的。可我刚刚在一个ANSI编译器上尝试过，其结果正如我所期望的。
3.12 我不想学习那些复杂的规则，怎样才能避免这些未定义的求值顺序问题呢？
其他的表达式问题
3.13 ++i和i++有什么区别？
3.14 如果我不使用表达式的值，那我应该用i++还是++i来做自增呢？
3.15 我要检查一个数是不是在另外两个数之间，为什么if（a b c）不行？
3.16 为什么如下的代码不对？int a=1000， b=1000; long int c=a * b;
3.17 为什么下面的代码总是给出0？double degC， degF; degC= 5.0 / 9 * （degF - 32）;
3.18 需要根据条件把一个复杂的表达式赋给两个变量中的一个。可以用下面这样的代码吗？（（condition） ？ a ： b）= complicated_expression;
3.19 我有些代码包含这样的表达式。a ？ b=c ： d 有些编译器可以接受，有些却不能。为什么？
保护规则
3.20 “semantics of‘’change in ANSI C”的警告是什么意思？
3.21 “无符号保护”和“值保护”规则的区别在哪里？

第4章 指针
基本的指针应用
4.1 指针到底有什么好处？
4.2 我想声明一个指针并为它分配一些空间，但却不行。这些代码有什么问题呢？char *p; *p =malloc（10）;
4.3 *p++自增p还是p所指向的变量？
指针操作
4.4 我用指针操作int数组的时候遇到了麻烦。
4.5 我有一个char *型指针碰巧指向一些int型变量，我想跳过它们。为什么（（int *）p）++; 这样的代码不行？
4.6 为什么不能对void *指针进行算术操作？
4.7 我有些解析外部结构的代码，但是它却崩溃了，显示出了“unaligned access”（未对齐的访问）的信息。这是什么意思？
作为函数参数的指针
4.8 我有个函数，它应该接受并初始化一个指针：void f（int *ip）{ static int dummy = 5; ip = &dummy;}但是当我如下调用时：int *ip; f（ip）; 调用者的指针没有任何变化。
4.9 能否用void ** 通用指针作为参数，使函数模拟按引用传递参数？ 48
4.10 我有一个函数extern intf（int *）; ，它接受指向int型的指针。我怎样用引用方式传入一个常数？调用f（&5）;似乎不行。
4.11 C语言可以“按引用传参”吗？
其他指针问题
4.12 我看到了用指针调用函数的不同语法形式。到底怎么回事？
4.13 通用指针类型是什么？当我把函数指针赋向void *类型的时候，编译通不过。
4.14 怎样在整型和指针之间进行转换？能否暂时把整数放入指针变量中，或者相反？
4.15 我怎样把一个int变量转换为char *型？我试了类型转换，但是不行。

第5章 空指针
空指针和空指针常量
5.1 臭名昭著的空指针到底是什么？
5.2 怎样在程序里获得一个空指针？
5.3 用缩写的指针比较“if（p）”检查空指针是否有效？如果空指针的内部表达不是0会怎样？
NULL 宏
5.4 NULL是什么，它是怎么定义的？
5.5 在使用非零位模式作为空指针的内部表示的机器上，NULL 是如何定义的？
5.6 如果NULL定义成#define NULL（（char *）0） ，不就可以向函数传入不加转换的NULL 了吗？
5.7 我的编译器提供的头文件中定义的NULL为0L。为什么？
5.8 NULL可以合法地用作函数指针吗？
5.9 如果NULL和0作为空指针常量是等价的，那我到底该用哪一个呢？
5.10 但是如果NULL的值改变了，比如在使用非零内部空指针的机器上，用NULL（而不是0）
不是更好吗？
5.11 我曾经使用过一个编译器，不使用NULL就不能编译。
5.12 我用预处理宏#define Nullptr（type）（type *）0帮助创建正确类型的空指针。
回顾
5.13 这有点奇怪：NULL可以确保是0，但空（null）指针却不一定？
5.14 为什么有那么多关于空指针的疑惑？为什么这些问题如此频繁地出现？
5.15 有没有什么简单点儿的办法理解所有这些与空指针有关的东西呢？
5.16 考虑到有关空指针的所有这些困惑，要求它们的内部表示都必须为0不是更简单吗？
5.17 说真的，真有机器用非零空指针吗，或者不同类型用不同的表示？
地址0上到底有什么？
5.18 运行时的整数值0转换为指针以后一定是空指针吗？
5.19 如何访问位于机器地址0处的中断向量？如果我将指针值设为0，编译器可能会自动将它转换为非零的空指针内部表示。
5.20 运行时的“null pointer assignment”错误是什么意思？应该怎样捕捉它？

第6章 数组和指针
数组和指针的基本关系
6.1 我在一个源文件中定义了char a[6]，在另一个源文件中声明了extern char *a。为什么不行？
6.2 可是我听说char a[]和char *a是等价的。是这样的吗？
6.3 那么，在C语言中“指针和数组等价”到底是什么意思？
6.4 既然它们这么不同，那为什么作为函数形参的数组和指针声明可以互换呢？
数组不能被赋值
6.5 为什么不能这样向数组赋值？extern char *getpass（）; char str[10]; str=getpass（"Enter password："）;
6.6 既然不能向数组赋值，那这段代码为什么可以呢？int f（char str[]）{ if（str[0] == \0） str="none";}
6.7 如果你不能给它赋值，那么数组如何能成为左值呢？
回顾
6.8 现实地讲，数组和指针的区别是什么？
6.9 有人跟我讲，数组不过是常指针。这样讲准确吗？
6.10 我还是很困惑。到底指针是一种数组，还是数组是一种指针？
6.11 我看到一些“搞笑”的代码，包含5["abcdef"]这样的“表达式”。这为什么是合法的C语言表达式呢？
数组的指针
6.12 既然数组引用会退化为指针，如果array是数组，那么array和&array又有什么区别呢？
6.13 如何声明一个数组的指针？
动态数组分配
6.14 如何在运行时设定数组的大小？怎样才能避免固定大小的数组？
6.15 我如何声明大小和传入的数组一样的局部数组？
6.16 如何动态分配多维数组？
6.17 有个很好的窍门，如果我这样写：int realarray[10]; int *array = &realarray[-1]; 我就可以把“array”当作下标从1 开始的数组。
函数和多维数组
6.18 当我向一个接受指针的指针的函数传入二维数组的时候，编译器报错了。
6.19 我怎样编写接受编译时宽度未知的二维数组的函数？
6.20 我怎样在函数参数传递时混用静态和动态多维数组？
数组的大小
6.21 当数组是函数的参数时，为什么sizeof不能正确报告数组的大小？
6.22 如何在一个文件中判断声明为extern的数组的大小（例如，数组定义和大小在另一个文件中）？sizeof操作符似乎不行。
6.23 sizeof返回的大小是以字节计算的，怎样才能判断数组中有多少个元素呢？
第7章 内存分配
第8章　字符和字符串
第9章　布尔表达式和变量
第10章　C预处理器
第11章　ANSI/ISO标准C
第12章　标准输入输出库
第13章　库函数
第14章　浮点运算
第15章　可变参数列表
第16　章 奇怪的问题
第17章　风格
第18章　工具和资源
第19章　系统依赖
第20章　杂项
术语表
参考文献

[ 本帖最后由 tiankai001 于 2013-9-10 23:14 编辑 ]

tiankai001

C语言的科学和艺术


《C语言的科学和艺术》是计算机科学的经典教材，介绍了计算机科学的基础知识和程序设计的专门知识。《C语言的科学和艺术》以介绍ANSI C为主线，不仅涵盖C语言的基本知识，而且介绍了软件工程技术以及如何应用良好的程序设计风格进行开发等内容。《C语言的科学和艺术》采用了库函数的方法，强调抽象的原则，详细阐述了库和模块化开发。此外，《C语言的科学和艺术》还利用大量实例讲述解决问题的全过程，对开发过程中常见的错误也给出了解决和避免的方法。《C语言的科学和艺术》既可作为高等院校计算机科学入门课程及C语言入门课程的教材，也是C语言开发人员的极佳参考书。


前言
第1章 概述
1.1 计算简史
1.2 什么是计算机科学
1.3 计算机硬件简介
1.3.1 cpu
1.3.2 内存
1.3.3 辅助存储器
1.3.4 i/o设备
1.4 算法
1.5 程序设计语言和编译
1.6 编程错误和调试
1.7 软件维护
1.8 软件工程的重要性
1.9 关于c程序设计语言的一些思考
小结
复习题
第一部分 c语言程序设计基础
第2章 通过例子学习
2.1 &"hello world&"程序
2.1.1 注释
2.1.2 库包含
2.1.3 主程序
2.2 两个数的加法程序
2.2.1 输入阶段
2.2.2 计算阶段
2.2.3 输出阶段
2.3 有关程序设计过程的观点
2.4 数据类型
2.4.1 浮点型数据
2.4.2 字符串类型的数据
2.5 表达式
2.5.1 常量
2.5.2 变量
2.5.3 赋值语句
2.5.4 运算符和操作数
2.5.5 整型数和浮点型数的结合
2.5.6 整数除法和求余运算符
2.5.7 优先级
2.5.8 优先级法则的应用
2.5.9 类型转换
小结
复习题
程序设计练习
第3章 问题求解
3.1 程序设计习语和范例
3.1.1 复合赋值习语
3.1.2 自增和自减运算符
3.2 解决规模稍大的问题
3.3 控制语句
3.3.1 重复n次习语
3.3.2 迭代和循环
3.3.3 下标变量
3.3.4 初始化的重要性
3.3.5 读入-直到-标志习语
3.3.6 创造一个更实用的应用程序
3.3.7 条件执行和if语句
3.4 一个调试练习
3.5 格式化输出
3.5.1 printf的格式码
3.5.2 控制空格、对齐方式和精度
3.6 构思一个程序
3.6.1 程序设计风格
3.6.2 设计时考虑将来的修改
3.6.3 #define机制
小结
复习题
程序设计练习
第4章 语句形式
4.1 简单语句
4.1.1 赋值的嵌套
4.1.2 多重赋值
4.1.3 程序块
4.2 控制语句
4.3 布尔型数据
4.3.1 关系运算符
4.3.2 逻辑运算符
4.3.3 简化求值
4.3.4 标志
4.3.5 避免布尔表达式中的冗余
4.3.6 布尔计算示例
4.4 if语句
4.4.1 单行if语句
4.4.2 多行if语句
4.4.3 if/else语句
4.4.4 级联if语句
4.4.5 ?: 运算符（可选的）
4.5 switch语句
4.6 while语句
4.6.1 while循环的应用
4.6.2 无限循环
4.6.3 解决半途退出问题
4.7 for语句
4.7.1 嵌套的for循环
4.7.2 for和while的关系
4.7.3 for语句中浮点型数据的使用问题
小结
复习题
程序设计练习
第5章 函数
5.1 使用库函数
5.2 函数声明
5.3 自己编写函数
5.3.1 return语句
5.3.2 将函数与主程序放在一起
5.3.3 包含内部控制结构的函数
5.3.4 返回非数字值的函数
5.3.5 谓词函数
5.3.6 测试字符串是否相等的谓词函数
5.4 函数调用过程机制
5.4.1 参数传递
5.4.2 在其他函数中调用函数
5.5 过程
5.6 逐步精化
5.6.1 从顶开始
5.6.2 实现printcalendar
5.6.3 实现printcalendarmonth
5.6.4 完成最后的片段
小结
复习题
程序设计练习
第6章 算法
6.1 测试素数
6.1.1 一个isprime的简单版本
6.1.2 验证一个策略是否表示一个算法
6.1.3 说明isprime算法的正确性
6.1.4 改进算法的效率
6.1.5 在各个可选方案中选择
6.2 计算最大公约数
6.2.1 brute-force算法
6.2.2 欧几里得算法
6.2.3 欧几里得算法的正确性说明（可选）
6.2.4 比较gcd算法的效率
6.3 数值算法
6.3.1 连续逼近
6.3.2 报告错误
6.4 级数展开
6.4.1 zeno悖论
6.4.2 用级数展开法设计平方根函数
6.4.3 估计平方根的泰勒级数展开 （可选）
6.4.4 泰勒级数近似的实现
6.4.5 停留在收敛半径之内
6.5 指定数值类型的大小
6.5.1 整数类型
6.5.2 无符号类型
6.5.3 浮点类型
小结
复习题
程序设计练习
第二部分 库和模块化开发
第7章 库和接口：一个简单的图形库
7.1 接口的概念
7.2 图形库介绍
7.2.1 graphics.h的基本模型
7.2.2 graphics.h接口的函数
7.2.3 软件包初始化
7.2.4 画直线
7.2.5 画圆和弧
7.2.6 获取有关图形窗口的信息
7.3 建立自己的工具
7.3.1 定义drawbox
7.3.2 定义drawcenteredcircle
7.3.3 绝对坐标和相对坐标间的切换
7.3.4 定义过程的好处
7.4 解决一个较大的问题
7.4.1 使用逐步精化
7.4.2 实现drawhouse过程
7.4.3 寻找共同的模式
7.4.4 结束分解
小结
复习题
程序设计练习
第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.2.3 ansi c中生成伪随机数
8.2.4 改变随机数的范围
8.2.5 将此问题通用化
8.3 在库中保存工具
8.3.1 接口的内容
8.3.2 写random.h接口
8.3.3 random.c的实现
8.3.4 构造客户程序
8.3.5 初始化随机数发生器
8.4 评价random.h接口的设计
8.4.1 产生随机实数
8.4.2 模拟一个概率事件
8.4.3 在接口中包含头文件
8.4.4 完成随机数软件包的实现
8.5 使用随机数软件包
小结
复习题
程序设计练习
第9章 字符串和字符
9.1 枚举的原理
9.1.1 在机器内部表示枚举类型
9.1.2 将枚举类型表示为整数
9.1.3 定义新的枚举类型
9.1.4 枚举类型的操作
9.1.5 标量类型
9.2 字符
9.2.1 数据类型char
9.2.2 ascii代码
9.2.3 字符常量
9.2.4 ascii代码方案的重要特性
9.2.5 特殊字符
9.2.6 字符运算
9.2.7 ctype.h接口
9.2.8 涉及字符的控制语句
9.2.9 字符的输入输出
9.3 字符串作为抽象数据类型
9.3.1 分层抽象
9.3.2 抽象类型的概念
9.4 strlib.h接口
9.4.1 确定字符串的长度
9.4.2 从一个字符串中选择字符
9.4.3 连接
9.4.4 将字符转换为字符串
9.4.5 抽取字符串的一部分
9.4.6 比较两个字符串
9.4.7 在一个字符串内搜索
9.4.8 大小写转换
9.4.9 数值转换
9.4.10 效率和strlib.h库
小结
复习题
程序设计练习
第10章 模块化开发
10.1 pig latin—一个模块化开发的 案例研究
10.1.1 应用自顶向下的设计
10.1.2 使用伪代码
10.1.3 实现translateline
10.1.4 考虑空格和标点符号的问题
10.1.5 精化单词的定义
10.1.6 设计记号扫描器
10.1.7 完成translateline的实现
10.1.8 定义扫描器模块接口
10.2 在模块中维护内部状态
10.2.1 全局变量
10.2.2 使用全局变量的危险性
10.2.3 保持变量的模块私有化
10.2.4 初始化全局变量
10.2.5 私有函数
10.3 实现扫描器抽象
小结
复习题
程序设计练习
第三部分 复合数据类型
第11章 数组
11.1 数组
11.1.1 数组声明
11.1.2 数组选择
11.1.3 一个简单的数组实例
11.1.4 改变下标值的范围
11.2 数据的内部表示法
11.2.1 比特、字节和字
11.2.2 内存地址
11.2.3 运算符sizeof
11.2.4 变量的内存分配
11.2.5 引用超出数组范围的元素
11.3 数组作为参数进行传递
11.3.1 元素个数的通用化
11.3.2 数组参数传递机制
11.3.3 实现函数printintegerarray和getintegerarray
11.3.4 实现函数reverseintegerarray
11.3.5 实现函数swapintegerelements
11.4 使用数组制作表格
11.5 数组的静态初始化
11.5.1 自动确定数组大小
11.5.2 确定初始化数组的大小
11.5.3 初始化数组和标量类型
11.6 多维数组
11.6.1 向函数传送多维数组
11.6.2 初始化多维数组
小结
复习题
程序设计练习
第12章 查找和排序
12.1 查找
12.1.1 在整数数组中查找
12.1.2 关于查找的另一个更复杂 的例子
12.1.3 线性查找
12.1.4 二分查找
12.1.5 查找算法的相对效率
12.2 排序
12.2.1 对一个整数数组排序
12.2.2 选择排序算法
12.2.3 选择排序效率的评估
12.2.4 测试程序的运行时间
12.2.5 选择排序的算法分析
小结
复习题
程序设计练习
第13章 指针
13.1 将地址作为数据值
13.2 c语言的指针操作
13.2.1 在c语言中声明指针变量
13.2.2 基本的指针操作
13.2.3 特殊指针null
13.3 通过引用传递参数
13.3.1 设计函数swapinteger
13.3.2 用引用调用返回多个结果
13.3.3 过度使用引用调用的危险
13.4 指针和数组
13.4.1 指针运算
13.4.2 运算符＋＋和－－的新作用
13.4.3 指针的自增和自减
13.4.4 指针和数组的关系
13.5 动态分配
13.5.1 void *类型
13.5.2 动态数组
13.5.3 查找malloc中的错误
13.5.4 释放内存
小结
复习题
程序设计练习
第14章 再论字符串
14.1 string类型的概念表示
14.1.1 字符串作为数组
14.1.2 字符串作为指针
14.1.3 字符串作为抽象类型
14.1.4 字符串参数
14.1.5 字符串变量
14.1.6 指针和数组变量间的区别
14.1.7 决定字符串的表示方法
14.2 ansi字符串库
14.2.1 strcpy函数
14.2.2 strncpy函数
14.2.3 strcat和strncat函数
14.2.4 strlen、strcmp和strncmp函数
14.2.5 strchr、strrchr和strstr函数
14.2.6 ansi字符串函数的应用
14.3 strlib库的实现
14.3.1 实现转换函数
14.3.2 strlib分配函数的实现
小结
复习题
程序设计练习
第15章 文件
15.1 文本文件
15.2 c语言中文件的使用
15.2.1 声明file*类型的变量
15.2.2 打开文件
15.2.3 执行i/o操作
15.2.4 关闭文件
15.2.5 标准文件
15.3 字符i/o
15.3.1 文件更新
15.3.2 在输入文件中重新读取字符
15.4 面向行的i/o
15.5 格式化i/o
15.5.1 printf的三种形式
15.5.2 scanf函数
15.5.3 用scanf读入字符串
15.5.4 格式化i/o的一个实例
15.5.5 使用scanf的局限
小结
复习题
程序设计练习
第16章 记录
16.1 数据记录的概念
16.2 记录在c语言中的使用
16.2.1 定义一个结构类型
16.2.2 声明结构变量
16.2.3 记录选择
16.2.4 记录初始化
16.2.5 简单记录
16.3 数组与记录的结合
16.4 记录的指针
16.4.1 定义一个指向记录类型的指针
16.4.2 为记录数据分配空间
16.4.3 对记录指针进行操作
16.5 创建记录的数据库
16.5.1 创建员工信息数据库
16.5.2 数据库的使用
16.6 基于记录的应用程序设计
16.6.1 使用数据库的重要性
16.6.2 问题的框架
16.6.3 设计内部表示
16.6.4 设计外部结构
16.6.5 程序代码
16.6.6 数据驱动设计方法的重要性
小结
复习题
程序设计练习
第17章 深入学习
17.1 递归
17.1.1 递归的简单说明
17.1.2 factorial函数
17.1.3 递归信任
17.1.4 递归范例
17.1.5 排列的生成
17.1.6 用递归的思想思考
17.2 抽象数据类型
17.2.1 队列抽象
17.2.2 以队列抽象表示类型
17.2.3 queue.h 接口
17.2.4 实现队列抽象
17.2.5 队列抽象的另一种实现方法
17.3 算法分析
17.3.1 评估算法效率
17.3.2 o标记
17.3.3 再看选择排序
17.3.4 分而治之策略
17.3.5 合并两个数组
17.3.6 合并排序算法
17.3.7 合并排序的计算复杂性
17.3.8 比较平方复杂性与nlogn复杂性的性能
小结
复习题
程序设计练习
附 录
附录a c语言的语法和结构总结
附录b 库源代码

[ 本帖最后由 tiankai001 于 2013-9-10 23:14 编辑 ]

tiankai001

C数值算法

本书编写了300多个实用而有效的数值算法C语言程序。其内容包括：线性方程组的求解，逆矩阵和行列式计算，多项式和有理函数的内插与外推，函数的积分和估值，特殊函数的数值计算，随机数的产生，非线性方程求解，傅里叶变换和FFT，谱分析和小波变换，统计描述和数据建模，常微分方程和偏微分方程求解，线性预测和线性预测编码，数字滤波，格雷码和算术码等。全书内容丰富，层次分明，是一本不可多得的有关数值计算的C语言程序大全。本书每章中都论述了有关专题的数学分析、算法的讨论与比较，以及算法实施的技巧，并给出了标准C语言实用程序。这些程序可在不同计算机的C语言编程环境下运行。
　　本书可作为从事科学计算的科技工作者的工具书，计算机软件开发者的参考书，也可以作为大学本科生和研究生的参考书或教材。



第1章 绪论

1.0 引言
1.0.1 计算环境和程序有效性
1.0.2 和本书第一版的兼容性
1.0.3 关于参考文献
1.1 程序组织和控制结构
1.1.1 控制结构
1.1.2 标准结构目录
1.1.3 关于“深入讨论”
1.2 科学计算的c约定
1.2.1 函数原型和头文件
1.2.2 向量和一维数级
1.2.3 矩阵和二维数组
1.2.4 复数运算
1.2.5 浮点数到双精度数的隐式转换
1.2.6 一些技巧
1.3 误差、准确性和稳定性

第2章 线性代数方程组求解
.
2.0 引言
2.0.1 非奇异与奇异方程组
2.0.2 矩阵
2.0.3 线性代数数值计算的任务
2.0.4 标准程序包
2.1 gauss-jordan消去法
2.1.1 列增广矩阵消去法
2.1.2 选主元法
2.1.3 深入讨论：行和列消去法策略
2.2 代过程的高斯消去法
2.2.1 回代过程
2.3 lu分解法及其应用
2.3.1 进行lu分解
2.3.2 矩阵的求逆
2.3.3 矩阵的行列式
2.3.4 深入讨论：复数系统方程
2.4 三对角及带状对角系统方程
2.4.1 深入讨论：带状对角系统
2.5 线性方程组解的迭代改进
2.5.1 深入讨论：关于解的迭代改进的更多讨论
2.6 奇异值分解
2.6.1 方阵的svd
2.6.2 方程个数少于未知数个数的svd
2.6.3 方程个数多于未知数个数的svd
2.6.4 构造标准正交基
2.6.5 矩阵的近似
2.6.6 svd算法
2.7 稀疏线性方程组
2.7.1 sherman-morrison公式
2.7.2 周期三对角方程组
2.7.3 深入讨论：woodlbury公式
2.7.4 分区求逆
2.7.5 深入讨论：稀疏矩阵的索引存储
2.7.6 深入讨论：共轭梯度法求解稀疏方程组
2.8 vandermonde矩阵和toeplitz矩阵
2.8.1 深入讨论：vandermonde矩阵
2.8.2 深入讨论：toeplitz矩阵
2.9 深入讨论：cholesky分解
2.10 深入讨论：qr分解
2.10.1 深入讨论：更新qr分解
2.11 矩阵求逆是否n3阶运算

第3章 内插法和外推法

3.0 引言
3.1 多项式内插法和外推法
3.2 有理函数内插法和外推法
3.3 三次样条插值
3.4 搜索有序表的方法
3.4.1 用相关数值进行搜索
3.4.2 写在hunt之后
3.5 插值多项式的系数
3.5.1 其他方法
3.6 二维或高维插值
3.6.1 用更高的阶获得高精度
3.6.2 用更高的阶获得高平滑度：双三次插值
3.6.3 用更高的阶获得高平滑度：双三次样条

第4章 函数积分

4.0 引言
4.1 坐标等距划分的经典公式
4.1.1 newton-cotes闭型公式
4.1.2 单个区间的外推公式
4.1.3 扩展公式（闭型）
4.1.4 扩展公式（开型与半开型）
4.2 基本算法
4.3 龙贝格积分
4.4 广义积分
4.5 高斯求积法与正交多项式
4.5.1 坐标点和权的计算
4.5.2 深入讨论：递推式已知时的情况
4.5.3 深入讨论：具有非经典权的正交多项式
4.5.4 高斯积分推广
4.6 多维积分

第5章 函数求值

5.0 引言
5.1 级数与其收敛性
5.1.1 加速级数收敛
5.2 连分式求值
5.2.1 连分式处理
5.3 多项式和有理函数
5.3.1 有理函数
5.4 复数运算
5.5 递推关系及clenshaw递推公式
5.5.1 递推式的稳定性
5.5.2 clenshaw递推公式
5.6 二次方程和三次方程
5.7 数值求异
5.8 切比雪夫逼近
5.9 切比雪夫逼近函数的微分和积分
5.9.1 深入讨论：clenshaw-curtis积分法
5.10 切比雪夫系数的多项式逼近
5.11 深入讨论：幂级数化简
5.12 深入讨论：帕德逼近
5.13 深入讨论：有理切比雪夫逼近
5.14 线积分求函数值

第6章 特殊函数

6.0 引言
6.1 函数、b函数、阶乘、二项式系数
6.2 不完全函数、误差函数、概率函数、累积泊松函数
6.2.1 误差函数
6.2.2 累积泊松概率函数
6.2.3 概率函数
6.3 指数积分
6.4 不完全函数、学生分布、分布、累积二项式分布
6.4.1 学生分布概率函数
6.4.2 分布概率函数
6.4.3 累积二项式概率分布
6.5 整数阶贝塞尔函数
6.6 修正的整数阶贝塞尔函数
6.7 深入讨论：分数阶贝塞尔函数、艾里函数、球面贝塞尔函数
6.7.1 一般贝塞尔函数
6.7.2 修正贝塞尔函数
6.7.3 艾里函数
6.7.4 球面贝塞尔函数
6.8 球面调和函数
6.9 菲涅耳积分、余弦和正弦积分
6.9.1 菲涅耳积分
6.9.2 余弦和正弦积分
6.10 dawson积分
6.11 椭圆积分和雅可比椭圆函数
6.11.1 雅可比椭圆函数
6.12 超几何函数

第7章 随机数

7.0 引言
7.1 一致偏离
7.1.1 系统提供的随机数生成程序
7.1.2 可移植的随机数生成程序
7.1.3 深入讨论：快速而略有缺陷的生成程序
7.1.4 深入讨论：更快的生成程序
7.1.5 相对的执行时间和建议
7.2 变换方法：指数偏离和正态偏离
7.2.1 指数偏离
7.2.2 正态（高斯）偏离
7.3 拒绝方法：伽马偏离、泊松偏离、二项偏离
7.3.1 伽马分布
7.3.2 泊松偏离
7.3.3 二项偏离
7.4 随机位的生成
7.5 深入讨论：基于数据加密的随机序列
7.6 简单的蒙特卡罗积分
7.7 准随机序列
7.7.1 打丁超立方
7.8 深入讨论：自适应及递归蒙特卡罗方法
7.8.1 重要取样
7.8.2 分层取样
7.8.3 混合策略
7.8.4 自适应蒙特卡罗：vegas
7.8.5 递归分层取样

第8章 排序

8.0 引言
8.1 直接插入法和shell方法
8.1.1 shell方法
8.2 快速排序法
8.3 堆积排序法
8.4 索引和分秩
8.5 挑选第m大的元素
8.6 深入讨论：等价类的确定

第9章 求根与非线性方程组

9.0 引言
9.1 划界与二分
9.1.1 二分法
9.2 弦截法、试位法和ridders方法
9.2.1 ridders方法
9.3 van wijngaarden-dekker-brent方法
9.4 利用导数的newton-raphson方法
9.4.1 newton-raphson方法和分形
9.5 多项式的根
9.5.1 多项式的降阶
9.5.2 muller方法
9.5.3 拉盖尔方法
9.5.4 本征值方法
9.5.5 其他可靠的求根方法
9.5.6 根修正的技巧
9.6 非线性方程系统的newton-raphson方法
9.6.1 牛顿法与极小化
9.7 非线性方程系统的全局收敛法
9.7.1 深入讨论：线性搜索和回溯
9.7.2 深入讨论：多维弦截法—broyden方法
9.7.3 深入讨论：更先进的实现

第10章 函数的极值

10.0 引言
10.1 一维黄金分割搜索
10.1.1 确定初始划界为极小的例程
10.1.2 黄金分割搜索方法的例程
10.2 抛物线内插和一维brent方法
10.3 使用一阶导数的一维搜索方法
10.4 多维下降单纯形法
10.5 多维情况下的方向集(powell)方法
10.5.1 共轭方向
10.5.2 powell二次收敛方法
10.5.3 舍弃函数值下降最多的方向
10.5.4 线性极小化的实现
10.6 多维共轭梯度法
10.6.1 有关利用导数的线性极小化之说明
10.7 多维变度量法
10.7.1 深入讨论：变度量法的进一步实现
10.8 线性规划和单纯形法
10.8.1 线性规划基本定理
10.8.2 关于约束标准形式的单纯形法
10.8.3 将一般问题转化为约束标准形式
10.8.4 单纯形法的例程实现
10.8.5 其他线性规划方法简述
10.9 模拟退火法
10.9.1 组合极小化：旅行推销员问题
10.9.2 模拟退火法在连续极小化问题中的应用

第11章 特征系统

11.0 引言
11.0.1 定义和基本事实
11.0.2 左特征向量和右特征向量
11.0.3 矩阵的对角化
11.0.4 成品化特征系统程序的特征系统软件包
11.0.5 广义的和非线性特征值问题
11.1 对称矩阵的雅可比变换
11.2 将对称矩阵简化为三对角形式：givens约化和householder约化
11.2.1 givens方法
11.2.2 householder方法
11.3 三对角矩阵的特征值和特征向量
11.3.1 特征多项式的赋值
11.3.2 qr和ql算法
11.3.3 具有隐含位移的ql算法
11.4 埃尔米特矩阵
11.5 将一般矩阵化为hessenberg形式
11.5.1 配平
11.5.2 约化成hessenberg形式
11.6 实hessenberg矩阵的qr算法
11.7 用逆迭代法改进特征值并寻找特征向量

第12章 快速傅里叶变换

12.0 引言
12.1 离散样本数据的傅里叶变换
12.1.1 取样定理与混叠现象
12.1.2 离散傅里叶变换
12.2 快速傅里叶变换（fft）
12.2.1 其他fft算法
12.3 实函数的fft、正弦变换和余弦变换
12.3.1 两个实函数同时变换
12.3.2 单个实函数的fft
12.3.3 快速正弦和余弦变换
12.4 二维或多维的fft
12.5 二维和三维实数据的傅里叶变换
12.6 深入讨论：外部存储和局部内存的fft

第13章 傅里叶和谱的应用

13.0 引言
13.1 使用fft做卷积和解卷积
13.1.1 用零元填充的终端效应处理
13.1.2 fft对卷积的使用
13.1.3 大型数据集的卷积和解卷积
13.2 使用fft做相关和自相关
13.3 具有fft的最佳（维纳）滤波
13.4 使用fft做功率谱估计
13.4.1 数据开窗
13.5 深入讨论：时域中的数字滤波
13.5.1 线性滤波
13.5.2 fir（非递推）滤波
13.5.3 iir（递推）滤波
13.6 线性预测和线性预测编码
13.6.1 与最佳滤波的联系
13.6.2 线性预测
13.6.3 除掉线性预测的偏差
13.6.4 线性预测编码（lpc）
13.7 深入讨论：用最大熵（全极）方法的功率谱估计
13.8 深入讨论：非均匀取样数据的谱分析
13.8.1 lomb周期图快速计算
13.9 深入讨论：使用fft计算傅里叶积分
13.10 小波变换：
13.10.1 daubechies小波滤波系数
13.10.2 离散小波变换
13.10.3 小波特性
13.10.4 傅里叶域中的小波滤波
13.10.5 被截小波近似
13.10.6 多维小波变换
13.10.7 图像压缩
13.10.8 线性系统的快速求解
13.11 深入讨论：取样定理的数值应用

第14章 数据的统计描述

14.0 引言
14.1 分布的矩：均值、方差、偏斜度等
14.1.1 深入讨论：半不变量
14.1.2 中位数和众数
14.2 两种分布的均值和方差
14.2.1 对于显著不同均值的学生t检验
14.2.2 对于显著不同方差的f检验
14.3 两种分布是否不同
14.3.1 x2检验
14.3.2 k-s检验
14.3.3 深入讨论：k-s检验的变形
14.4 两种分布的列联表分析
14.4.1 基于x2的关联测度
14.4.2 基于熵的关联没度
14.5 线性相关
14.6 非参数相关或秩相关
14.6.1 spearman秩阶相关系数
14.6.2 kendall
14.7 深入讨论：二维分布
14.8 深入讨论：savitzky-colay平滑滤波器

第15章 数据建模

15.0 引言
15.1 最大似然估计的最小二乘方法
15.1.1 拟合
15.2 拟合数据成直线
15.3 深入讨论：两个坐标数据都有误差的直线拟合
15.4 一般的线性最小二乘方
15.4.1 利用正规方程组求解
15.4.2 运用奇异值分解法求解
15.4.3 示例
15.4.4 多维拟合
15.5 非线性模型
15.5.1 梯度和黑塞矩阵的计算
15.5.2 levenberg-marquardt方法
15.5.3 示例
15.5.4 非线性最小二乘方法的更先进方法
15.6 被估模型参数的置信界限
15.6.1 合成数据集的蒙特卡罗模拟
15.6.2 快速粗糙的蒙特卡罗方法：靴带法
15.6.3 置信界限
15.6.4 常数边界作为置信界限
15.6.5 正态情况下参数的概率分布
15.6.6 奇异值分解下的置信界限
15.7 稳健估计
15.7.1 用局部m估计法估计参数
15.7.2 m估计的数值计算
15.7.3 通过极小化绝对偏差拟合直线
15.7.4 其他的稳健估计方法

第16章 常微分方程的积分

16.0 引言
16.1 runge-kutta方法
16.2 runge-kutta方法的自适应步长控制
16.3 修正中点法
16.4 richardson外推法和bulirsch-stoer方法
16.5 深入讨论：二阶守恒方程组
16.6 方程的刚性集
16.6.1 深入讨论：rosenbrock方法
16.6.2 深入讨论：半隐式外推算法
16.7 多步法、多值法和预测-校正法

第17章 两点办界值问题

17.0 引言
17.0.1 能用标准边界问题求解的问题
17.1 打靶法
17.2 射向某一拟合点
17.3 深入讨论：松弛法
17.3.1 微分方程的“代数困难”集
17.4 实例：球体调和函数
17.4.1 松弛法
17.4.2 打靶法
17.4.3 射向某一拟合点
17.5 深入讨论：网格点的自动分配
17.6 深入讨论：内部边界条件或奇异点的处理

第18章 积分方程和反演理论

18.0 引言
18.1 第二类fredholm方程
18.2 volterra方程
18.3 深入讨论：具有奇异核的积分方程
18.3.1 具有任意权的均匀网格上的积分
18.3.2 实例：对角奇异核
18.4 反演问题与先验信息的利用
18.4.1 零阶正则化反演问题
18.5 线性正则化方法
18.5.1 二维问题和迭代方法
18.5.2 确定性约束：凸集投影
18.6 backus-gilbert方法
18.7 最大熵图像恢复
18.7.1 mem特性
18.7.2 mem的算法
18.7.3 bayes“bayes”与“历史性”的最大熵

第19章 偏微分方程

19.0 引言
19.0.1 初值问题
19.0.2 边界值问题
19.0.3 有限差分以外的众多方法
19.1 通量守恒的初值问题
19.1.1 von neumann稳定性分析
19.1.2 lax方法
19.1.3 其他种类的误差
19.1.4 时间域上的二阶精确度
19.1.5 含有激波的流体动力学
19.2 扩散初值问题
19.2.1 薛定谔方程
19.3 多维的初值问题
19.3.1 通量守恒方程的lax方法
19.3.2 多维的扩散问题
19.3.3 一般算子分裂法
19.4 边界值问题的傅里叶方法和循环约简法
19.4.1 傅里叶变换法
19.4.2 循环约简法
19.4.3 facr方法
19.5 边界值问题的松弛法
19.5.1 逐次超松弛法
19.5.2 交替方向隐式法
19.6 边界值问题的多重网格法
19.6.1 从一网格，到两网格，再到多网格
19.6.2 光滑、限制及拓展算子
19.6.3 完全多重网格算法
19.6.4 深入讨论：非线性多重网格，fas算法

第20章 非典型的数值算法

20.0 引言
20.1 诊断机器的参数
20.2 格雷码
20.3 循环冗余度校验和其他种类的校验和式
20.3.1 其他种类的校验和式
20.4 霍夫曼编写与数据压缩
20.4.1 游程编码
20.5 算术编码
20.6 任意精度的运算

附录a 原型声明表

附录b 实用例程

附录c 复数运算

参考文献

程序从属表

各章节的计算机程序

[ 本帖最后由 tiankai001 于 2013-9-10 23:00 编辑 ]

tiankai001

C语言解析教程

C语言在全世界的学术界和工业界都广泛地应用，同时它也是计算机科学教育编程课程的首选编程语言。本书通过应用作者首次提出的一种独特的教学方法——解析，对C语言的关键特征及编程过程做了细致全面的介绍。书中大量的练习和带有详细注释的工作程序会使读者从整体上提高编程能力、掌握编程技巧。本书的附录还给出了大量标准库函数供读者参考。
　　本书全面介绍了C语言的数组、指针、函数、串处理、文件处理和软件工具等方面的内容，本书是计算机专业本科生的极佳教材。

C语言在全世界的学术界和工业界都广泛地应用，同时它也是计算机科学教育编程课程的首选编程语言。本书通过应用作者首次提出的一种独特的教学方法—解析，对C语言的关键特征及编程过程做了细致全面的介绍。书中大量的练习和带有详细注释的工作程序会使读者从整体上提高编程能力、掌握编程技巧。本书的附录还给出了大量标准库函数供读者参考。
　　本书全面介绍了C语言的数组、指针、函数、串处理、文件处理和软件工具等方面的内容，本书是计算机专业本科生的极佳教材。


第1章 编写asni c程序        1
1.1 准备编程        1
1.2 第一个程序        2
1.3 变量、表达式和赋值        5
1.4 初始化        8
1.5 #define和#include的用法        8
1.6 printf()和scanf()的用法        9
1.6.1 printf()的用法        10
1.6.2 scanf()的用法        11
1.7 while语句        13
1.8 问题求解：计算总和        14
1.9 风格        15
1.10 常见的编程错误        16
1.11 系统考虑        17
1.11.1 编写和运行c程序        17
1.11.2 中断程序        18
1.11.3 输入文件尾标识        18
1.11.4 输入和输出的重定向        18
1.12 转向c++        19
.小结        20
练习        20
第2章 词法元素、运算符和c系统        26
2.1 字符和词法元素        27
2.2 注释        28
2.3 关键字        29
2.4 标识符        29
2.5 常量        30
2.6 串常量        31
2.7 运算符和标点符号        31
2.8 运算符的优先级和结合性        32
2.9 增量运算符和减量运算符        33
2.10 赋值运算符        34
2.11 例子：计算2的幂        36
2.12 c系统        36
2.12.1 预处理器        37
2.12.2 标准库        37
2.13 风格        39
2.14 常见的编程错误        40
2.15 系统考虑        41
2.16 转向c++        42
小结        42
练习        43
第3章 控制流        48
3.1 关系、等式和逻辑运算符        48
3.2 关系运算符和表达式        49
3.3 等式运算符和表达式        50
3.4 逻辑运算符和表达式        50
3.5 复合语句        53
3.6 空语句        53
3.7 if和if-else语句        53
3.8 while语句        56
3.9 问题求解：找最大值        57
3.10 for语句        58
3.11 问题求解：组合数学        59
3.12 问题求解：布尔变量        61
3.13 逗号运算符        61
3.14 do语句        62
3.15 goto语句        63
3.16 break和continue语句        64
3.17 switch语句        65
3.18 嵌套的控制流        65
3.19 条件运算符        66
3.20 风格        67
3.21 常见的编程错误        68
3.22 系统考虑        70
3.23 转向c++        71
小结        71
练习        72
第4章 函数和结构化编程        78
4.1 函数调用        78
4.2 函数定义        78
4.3 return语句        80
4.4 函数原型        82
4.5 自顶向下设计        83
4.6 程序的正确性：assert()宏        86
4.7 从编译器的角度来看函数声明        87
4.8 问题求解：随机数        88
4.9 函数定义次序的可选风格        89
4.10 开发一个大程序        90
4.11 模拟：正反面游戏        93
4.12 调用和按值调用        95
4.13 递归        96
4.14 风格        97
4.15 常见的编程错误        97
4.16 系统考虑        99
4.17 转向c++        100
小结        102
练习        103
第5章 字符处理        110
5.1 数据类型char        110
5.2 getchar()和putchar()的用法        112
5.3 例子：大写        115
5.4 ctype.h中的宏        117
5.5 问题求解：重复字符        117
5.6 问题求解：对单词计数        118
5.7 风格        120
5.8 常见的编程错误        121
5.9 系统考虑        122
5.10 转向c++        123
小结        125
练习        125
第6章 基本数据类型        128
6.1 声明和表达式        128
6.2 基本数据类型        128
6.3 字符和数据类型char        129
6.4 数据类型int        130
6.5 整数类型short、long和unsigned        131
6.6 浮点类型        132
6.7 sizeof运算符        134
6.8 数学函数        134
6.9 转换和类型转换        136
6.9.1 整型提升        136
6.9.2 常用的算术转换        136
6.9.3 类型转换        137
6.10 问题求解：计算利息        138
6.11 风格        141
6.12 常见的编程错误        142
6.13 系统考虑        143
6.14 转向c++        143
小结        144
练习        145
第7章 枚举类型和typedef        151
7.1 枚举类型        151
7.2 typedef的用法        152
7.3 例子：石头、剪刀、布游戏        154
7.4 风格        158
7.5 常见的编程错误        159
7.6 系统考虑        160
7.7 转向c++        160
小结        160
练习        161
第8章 函数、指针和存储类型        165
8.1 指针声明和赋值        165
8.2 地址和间接访问        166
8.3 指向void的指针        169
8.4 引用调用        170
8.5 作用域规则        171
8.6 存储类型        172
8.6.1 存储类型auto        172
8.6.2 存储类型extern        172
8.6.3 存储类型register        174
8.6.4 存储类型static        174
8.7 静态外部变量        175
8.8 缺省的初始化        176
8.9 例子：字符处理        176
8.10 函数声明和函数定义        179
8.11 类型限定符const和volatile        179
8.12 风格        180
8.13 常见的编程错误        181
8.14 系统考虑        182
8.15 转向c++        183
小结        184
练习        185
第9章 数组和指针        190
9.1 一维数组        190
9.1.1 初始化        191
9.1.2 下标        192
9.2 例子：分别对每个字母计数        192
9.3 数组和指针间的关系        194
9.4 指针运算和元素尺寸        195
9.5 把数组传递给函数        195
9.6 排序算法：冒泡排序        196
9.7 二维数组        197
9.8 多维数组        199
9.9 动态内存分配        200
9.10 风格        201
9.11 常见的编程错误        203
9.12 系统考虑        203
9.13 转向c++        204
小结        205
练习        206
第10章 串和指针        211
10.1 串结束标志        211
10.2 串的初始化        212
10.3 例子：心情愉快        212
10.4 用指针处理串        214
10.5 问题求解：单词计数        217
10.6 把参数传递给main()        218
10.7 标准库中的串处理函数        218
10.8 风格        220
10.9 常见的编程错误        220
10.10 系统考虑        221
10.11 转向c++        221
小结        221
练习        222
第11章 递归        225
11.1 递归问题求解        225
11.2 例子：在屏幕上绘制图案        228
11.3 用递归处理串        229
11.4 分而治之方法        230
11.5 例子：汉诺塔        231
11.6 风格        237
11.7 常见的编程错误        238
11.8 系统考虑        239
11.9 转向c++        239
小结        240
练习        240
第12章 结构和抽象数据类型        245
12.1 声明结构        245
12.2 访问成员        246
12.3 运算符的优先级和结合性：总结        248
12.4 结构、函数和赋值        249
12.5 问题求解：学生记录        251
12.6 结构的初始化        253
12.7 typedef的用法        253
12.8 自引用结构        254
12.9 线性链表        255
12.10 对链表的操作        256
12.11 计数和查找        257
12.12 插入和删除        258
12.13 风格        259
12.14 常见的编程错误        260
12.15 系统考虑        260
12.16 转向c++        261
小结        266
练习        266
第13章 输入/输出和文件        269
13.1 输出函数printf()        269
13.2 输入函数scanf()        272
13.2.1 控制串中的指示        273
13.2.2 普通字符        273
13.2.3 空白字符        273
13.2.4 转换说明        273
13.2.5 输入流中的浮点数        275
13.2.6 使用扫描集        275
13.2.7 返回值        276
13.2.8 一个scanf()的例子        276
13.3 函数sprintf()和sscanf()        277
13.4 函数fprintf()和fscanf()        277
13.5 访问文件        278
13.6 例子：对文件行距加倍        279
13.7 使用临时文件和得体的函数        281
13.8 随机地访问文件        283
13.9 风格        284
13.10 常见的编程错误        285
13.11 系统考虑        286
13.12 转向c++        287
小结        289
练习        290
第14章 软件工具        295
14.1 在c程序中执行命令        295
14.2 环境变量        296
14.3 c编译器        297
14.4 创建库        299
14.5 使用profiler        300
14.6 关于时间的编码        303
14.7 dbx的用法        305
14.8 make的用法        306
14.9 touch的用法        309
14.10 其他有用的工具        309
14.11 风格        310
14.12 常见的编程错误        310
14.13 系统考虑        311
小结        311
练习        312
第15章 从c到c++        315
15.1 为什么转到c++        315
15.2 类和抽象数据类型        317
15.3 重载        318
15.4 构造器和析构器        320
15.5 继承        321
15.6 多态性        322
15.7 模板        324
15.8 c++中的异常        325
15.9 面向对象编程的益处        325
15.10 风格        325
15.11 常见的编程错误        326
15.12 系统考虑        326
小结        326
练习        327
附录a 标准库        329
附录b 预处理器        354
附录c 位运算符        363
附录d ansi c与传统c的比较        375
附录e ascii字符编码表        380
附录f 运算符的优先级和结合性        381
索引        382

[ 本帖最后由 tiankai001 于 2013-9-10 23:01 编辑 ]

tiankai001

c语言编程常见问题解答

本书从基本概念、基本技术、技术细节和疑难问题4个角度，分C语言、变量和数据存储、排序与查找、编译预处理等21个专题，收集了有关C程序设计的308个常见的问题。每一问题的解答都配有简明而有说服力的例子程序，相关的问题之间还配有详尽的交叉索引，C程序设计的初学者通过本收可以迅速完善自己的知识体系，并有效地提高自己的编程水平。

这是一本专门解答c语言编程常见问题的著作。书中所覆盖的内容相当广泛，并附有大量鲜明的例子。c语言是一种非常优秀的编程语言，深受广大程序员的喜爱。然而，一个初学者往往要经过很长时间的编程实践，才能成为一名熟练的c程序员。即使是已有一定编程经验的c程序员，也会经常遇到各种难解的问题，从而无法编写出真正优质、高效、可移植性强的C程序。这里的一个重要原因是初学者往往要花很长时间才能比较全面地接触到C语言编程中的种种问题，而每遇到一个新的问题，又很少有好的参考书帮助他去解决这个问题。本书将带给读者一个非常广阔的视野。你只稍稍浏览一下本书的目录，就能马上领悟到在C语言编程中你真正要面临的是一系列怎样的问题。本书涉及的问题并不是很深，但本书内容的全面性却是众多C语言参考书中难得一见的。本书覆盖了C语言编程所涉及的几乎所有领域的问题，并且问题解答中的知识性很强。值得一提的是，另有两条基本思路贯穿于本书问题的组织和解答之中，即反复强调C语言及C编程基础知识和编程风格对程序员编程质量的重要影响，而这一点也许正是许多受到困扰的C程序员还未真正意识到的问题。
　　 本书主要适用于C语言编程的初学者和经验尚不丰富的C程序员。对那些急于投入到广泛的编程实践中去，急于提高和拓展自己的编程能力的初学者来说，本书确实是一位难得的好老师。


第1章 c语言
1．1 什么是局部程序块(localblock)?
1．2 可以把变量保存在局部程序块中吗?
1．3 什么时候用一条switch语句比用多条if语句更好?
1．4 switch语句必须包含default分支吗?
1．5 switch语句的最后一个分支可以不要break语句吗?
1．6 除了在for语句中之外，在哪些情况下还要使用逗号运算符?
1．7 怎样才能知道循环是否提前结束了?
1. 8 goto，longjmp()和setjmp()之间有什么区别?
1．9 什么是左值(lvaule)?
1．10 数组(array)可以是左值吗?
1．11 什么是右值(rvaule)?
1．12 运算符的优先级总能保证是"自左至右"或"自右至左"的顺序吗?
1．13 十十var和var十十有什么区别?
1．14 取模运算符(modulusoperator)"％"的作用是什么2
第2章　变量和数据存储
2．1 变量存储在内存(memory)中的什么地方?
2．2 变量必须初始化吗?
2．3 什么是页抖动(page thrashing)?
2．4 什么是const指针?
.2．5 什么时候应该使用register修饰符?它真的有用吗?
2．6 什么时候应该使用volatile修饰符?
2．7 一个变量可以同时被说明为const和volatile吗?
2．8 什么时候应该使用const修饰符?
2．9 浮点数比较(floating-point comparisons)的可靠性如何?
2．10 怎样判断一个数字型变量可以容纳的最大值?
2．11 对不同类型的变量进行算术运算会有问题吗?
2. 12 什么是运算符升级(operator promotion)?
2．13 什么时候应该使用类型强制转换(type cast)?
2．14 什么时候不应该使用类型强制转换(type cast)?
2．15 可以在头文件中说明或定义变量吗?
2，16 说明一个变量和定义一个变量有什么区别?
3．17 可以在头文件中说明static变量吗?
2．18 用const说明常量有什么好处?
第3章 排序与查找
3．1 哪一种排序方法最方便?
3．2 哪一种排序方法最快?
3．3 当要排序的数据集因太大而无法全部装入内存时，应怎样排序?
3．4 哪一种查找方法最方便?
3．5 哪一种查找方法最快?
3．6 什么是哈希查找?
3．7 怎样对链表进行排序?
3．8 怎样查找链表中的数据?
第4章 数据文件
4．1 当errno为一个非零值时，是否有错误发生?
4．2 什么是流(stream)?
4．3 怎样重定向一个标准流?
4．4 怎样恢复一个重定向了的标准流?
4．5 stdout能被强制打印到非屏幕设备上吗?
4．6 文本模式(text mode)和二进制模式(binary mode)有什么区别?
4．7 怎样判断是使用流函数还是使用低级函数?
4．8 怎样列出某个目录下的文件?
4．9 怎样列出一个文件的日期和时间?
4．10 怎样对某个目录下的文件名进行排序?
4．11 怎样判断一个文件的属性?
4．12 怎样查看path环境变量?
4．13 怎样打开一个同时能被其它程序修改的文件?
4．14 怎样确保只有你的程序能存取一个文件?
4. 15 怎样防止其它程序修改你正在修改的那部分文件内容?
4．16 怎样一次打开20个以上的文件?
4．17 怎样避开"abort，retry，fail"消息?
4. 18 怎样读写以逗号分界的文本?
第5章 编译预处理
5．1 什么是宏(macro)?怎样使用宏?
5．2　预处理程序(preprocessor)有什么作用?
5．3 怎样避免多次包含同一个头文件?
5．4 可以用#include指令包含类型名不是"．h"的文件吗?
5．5 用#define指令说明常量有什么好处?
5．6 用enum关键字说明常量有什么好处?
5．7 与用#define指令说明常量相比，用enum关键字说明常量有什么好处?
5. 8 如何使部分程序在演示版中失效?
5．9 什么时候应该用宏代替函数?
5. 10 使用宏更好，还是使用函数更好?
5. 11 在程序中加入注释的最好方法是什么?
5. 12 #include＜file＞和#include"file"有什么不同?
5. 13 你能指定在编译时包含哪一个头文件吗?
5．14 包含文件可以嵌套吗?
5．15 包含文件最多可以嵌套几层?
5．16 连接运算符"##"有什么作用?
5．17 怎样建立对类型敏感的宏?
5．18 什么是标准预定义宏?
5．19 怎样才能使程序打印出发生错误的行号?
5．20 怎样才能使程序打印出发生错误的源文件名?
5．21 怎样判断一个程序是用c编译程序还是用c++编译程序编译的?
5．22 预处理指令#pragma有什么作用?
5．23 #line有什么作用?
5．24 标准预定义宏_file_有什么作用?
5．25 怎样在程序中打印源文件名?
5．26 标准预定义宏_line_有什么作用?
5. 27 怎样在程序中打印源文件的当前行号?
5．28 标准预定义宏_date_和_time_有什么作用?
5．29 怎样在程序中打印编译日期和时间?
5．30 怎样判断一个程序是否遵循ansi c标准?
5．31 怎样取消一个已定义的宏?
5. 32 怎样检查一个符号是否已被定义?
5．33 c语言提供哪些常用的宏?
第6章 字符串操作
6. 1 串拷贝(strcpy)和内存拷贝(memcpy)有什么不同?它们适合于在哪种情况下
使用?
6．2 怎样删去字符串尾部的空格?
6．3 怎样删去字符串头部的空格?
6. 4 怎样使字符串右对齐?
6. 5 怎样将字符串打印成指定长度?
6. 6．怎样拷贝字符串的一部分?
6. 7 怎样将数字转换为字符串?
6. 8 怎样将字符串转换为数字?
6. 9 怎样打印字符串的一部分?
6. 10 怎样判断两个字符串是否相同?
第7章 指针和内存分配
7．1 什么是间接引用(indirection)?
7．2 最多可以使用几层指针?
7．3　什么是空指针?
7．4 什么时候使用空指针?
7．5　什么是void指针?
7．6 什么时候使用void指针?
7．7 两个指针可以相减吗?为什么?
7．8 把一个值加到一个指针上意味着什么?
7．9 null总是被定义为o吗?
7．10 null总是等于0吗?
7. 11 用指针作if语句的条件表达式意味着什么?
7．12 两个指针可以相加吗?为什么?
7．13 怎样使用指向函数的指针?
7．14 怎样用指向函数的指针作函数的参数?
7．15 数组的大小可以在程序运行时定义吗?
7．16 用malloc()函数更好还是用calloc()函数更好?
7．17 怎样说明一个大于64kb的数组?
7．18 far和near之间有什么区别?
7．19 什么时候使用far指针?
7．20 什么是栈(stack)?
7．21 什么是堆(heap)?
7．22 两次释放一个指针会导致什么结果?
7．23 null和nul有什么不同?
7．24 为什么不能给空指针赋值?什么是总线错误、内存错误和内存信息转储?
7．25 怎样确定一块已分配的内存的大小?
7，26 free()函数是怎样知道要释放的内存块的大小的?
7．27 可以对void指针进行算术运算吗?
7．28 怎样打印一个地址?
第8章 函数
8．1 什么时候说明函数?
8．2 为什么要说明函数原型?
8．3 一个函数可以有多少个参数?
8．4 什么是内部函数?
8．5 如果一个函数没有返回值，是否需要加入return语句?
8．6 怎样把数组作为参数传递给函数?
8．7 在程序退出main()函数之后，还有可能执行一部分代码吗?
8．8 用pascal修饰符说明的函数与普通c函数有什么不同?
8．9 exit()和return有什么不同?
第9章 数组
9．1 数组的下标总是从0开始吗?
9．2 可以使用数组后面第一个元素的地址吗?
9．3 为什么要小心对待位于数组后面的那些元素的地址呢?
9．4 在把数组作为参数传递给函数时，可以通过sizeof运算符告诉函数数组的
大小吗?
9．5 通过指针或带下标的数组名都可以访问数组中的元素，哪一种方式更好呢?
9．6 可以把另外一个地址赋给一个数组名吗?
9．7 array＿name和＆array_name有什么不同?
9．8 为什么用const说明的常量不能用来定义一个数组的初始大小?
9．9 字符串和数组有什么不同?
第10章 位(bit)和字节(byte)
10．1 用什么方法存储标志(flag)效率最高?
10，2 什么是"位屏蔽(bit masking)"?
10．3 位域(bit fields)是可移植的吗?
10．4 移位和乘以2这两种方式中哪一种更好?
10．5 什么是高位字节(high-order byte)和低位字节(low-orderbyte)?
10．6 16位和32位的数是怎样存储的?
第11章 调试
11．1 如果我运行的程序挂起了，应该怎么办?
11．2 如何检测内存漏洞(leak)?
11．3 调试程序的最好方法是什么?
11．4 怎样调试tsr程序?
11．5 怎样获得一个能报告条件失败的程序?
第12章 标准库函数
12．1 为什么应该使用标准库函数而不要自己编写函数?
12．2 为了定义我要使用的标准库函数，我需要使用哪些头文件?
12．3 怎样编写参数数目可变的函数?
12. 4 独立(free-standing)环境和宿主(hosted)环境之间有什么区别?
12．5 对字符串进行操作的标准库函数有哪些?
12. 6 对内存进行操作的标准库函数有哪些?
12. 7 怎样判断一个字符是数字、字母或其它类别的符号?
12. 8 什么是"局部环境(locale)"?
12. 9 有没有办法从一个或多个函数中跳出2
12. 10 什么是信号(signal)?用信号能做什么2
12．11 为什么变量名不能以下划线开始?
12．12 为什么编译程序提供了两个版本的malloc()函数?
12．13 适用于整数和浮点数的数学函数分别有哪些?
12．14 什么是多字节字符(multibyte characters)?
12．15 怎样操作由多字节字符组成的字符串?
第13章 时间和日期
13．1 怎样把日期存储到单个数字中?有这方面的标准吗?
13．2 怎样把时间存储到单个数字中?有这方面的标准吗?
13．3 为什么定义了这么多不同的时间标准?
13．4 存储日期的最好方法是哪一种?
13．5 存储时间的最好方法是哪一种?
第14章 系统调用
14．1 怎样检查环境变量(environment variables)的值?
14．2 怎样在程序中调用dos函数?
14．3 怎样在程序中调用bios函数?
14．4 怎样在程序中存取重要的dos内存位置?
14．5 什么是bios?
14．6 什么是中断?
14．7 使用ansi函数和使用bios函数，哪种方式更好?
14．8 可以通过bios把显示模式改为vga图形模式吗?
14．9 运算符的优先级总能起作用吗(从左至右，从右至左)?
14．10 函数参数的类型必须在函数头部或紧跟在其后说明吗?为什么?
14．11 程序应该总是包含main()的一个原型吗?
14．12 main()应该总是返回一个值吗?
14．13 可以通过bios控制鼠标吗?
第15章 可移植性
15．1 编译程序中的c++扩充功能可以用在c程序中吗?
15．2 c++和c有什么区别?
15．3 在c程序中可以用"／／"作注释符吗?
15．4 char，short，int和long类型分别有多长?
15．5 高位优先(big-endian)与低位优先(little-endian)的计算机有什么区别?
第16章 ansi／iso标准
16．1 运算符的优先级总能起作用吗?
16，2 函数参数类型必须在函数参数表中或紧跟其后的部分中说明吗?
16．3 程序中必须包含main()的原型吗?
16．4 main()应该总是返回一个值吗?
第17章 用户界面--屏幕和键盘
17．1 为什么直到程序结束时才看到屏幕输出?
17．2 怎样在屏幕上定位光标?
17．3 向屏幕上写数据的最简单的方法是什么?
17．4 向屏幕上写文本的最快的方法是什么?
17．5 怎样防止用户用ctr十break键中止程序的运行?
17．6 怎样才能只得到一种特定类型的数据，例如字符型数据?
17．7 为什么有时不应该用scanf()来接收数据?
17．8 怎样在程序中使用功能键和箭头键?
17．9 怎样防止用户向一个内存区域中输入过多的字符?
17．10 怎样用o补齐一个数字?
17．11 怎样才能打印出美元－美分值?
17．12 怎样按科学记数法打印数字?
17．13 什么是ansi驱动程序?
17．14 怎样通过ansi驱动程序来清屏?
17．15 怎样通过ansi驱动程序来存储光标位置?
17．16 怎样通过ansi驱动程序来恢复光标位置?
17．17 怎样通过ansi驱动程序来改变屏幕颜色?
17．18 怎样通过ansi驱动程序来写带有颜色的文本?
17．19 怎样通过ansi驱动程序来移动光标?
第18章 程序的编写和编译
18．1 程序是应该写成一个源文件还是多个源文件?
18．2 各种存储模式之间有什么区别?
18．3 最常使用的存储模式有哪些?
18．4 应该使用哪种存储模式?
18．5 怎样生成一个"．com"文件?
18．6 "．com"文件有哪些地方优于"．exe"文件?
18．7 当一个库被连接到目标上时，库中的所有函数是否都会被加到一个".exe"
文件中?
18．8 可以把多个库函数包含在同一个源文件中吗?
18．9 为什么要建立一个库?
18．10 如果一个程序包含多个源文件，怎样使它们都能正常工作?
18．11 连接过程中出现"dgroup：group exceeds 64k"消息是怎么回事？
18．12 怎样防止程序用尽内存?
18．13 如果程序太大而不能在dos下运行，怎样才能使它在dos下运行呢?
18．14 怎样才能使dos程序获得超过640kb的可用内存呢7
18．15 近程型(near)和远程型(far)的区别是什么?
第19章 编程风格和标准
19．1 可以在变量名中使用下划线吗?
19．2 可以用变量名来指示变量的数据类型吗?
19．3 使用注释会影响程序的速度、大小或效率吗?
19．4 使用空白符会影响程序的速度、大小或效率吗?
19．5 什么是骆驼式命名法?
19．6 较长的变量名会影响程序的速度、大小或效率吗?
19．7 给函数命名的正确方法是什么?
19．8 使用大括号的正确方法是什么?
19．9 一个变量名应该使用多少个字母?ansi标准允许有多少个有效字符?
19．10 什么是匈牙利式命名法?应该使用它吗?
19．11 什么是重复处理(iterative processing)?
19．12 什么是递归(recursion)?怎样使用递归?
19．13 在c语言中，表示真和假的最好方法是什么?
19，14 空循环(null loops)和无穷循环(infinite loops)有什么区别?
19．15 continue和break有什么区别?
第20章 杂项(miscellaneous)
20．1 怎样获得命令行参数?
20．2 程序总是可以使用命令行参数吗?
20．3 "异常处理(exception handling)"和"结构化异常处理(structured exception
handling)"有什么区别?
20．4 怎样在dos程序中建立一个延时器(delaytimer)?
20．5 kernighan和ritchie是谁?
20．6 怎样产生随机数?
20．7 什么时候应该使用32位编译程序?
20．8 怎样中断一个windows程序?
20．9 为什么要使用静态变量?
20．10 怎样在一个程序后面运行另一个程序?
20．11 怎样在一个程序执行期间运行另一个程序?
20．12 怎样把数据从一个程序传给另一个程序?
20．13 怎样判断正在运行的程序所在的目录?
20．14 怎样找到程序中的重要文件(数据库，配置文件，等等)?
20．15 本书的有些例子程序有许多缺陷，为什么不把它们写得更好?
20．16 怎样使用ctr十break失效?
20．17 可以使热启动(ctrl十alt十delete)失效吗?
20．18 怎样判断一个字符是否是一个字母?
20．19 怎样判断一个字符是否是一个数字?
20．20 怎样把一个十六进制的值赋给一个变量?
20.　21 怎样把一个八进制的值赋给一个变量?
20.　22 什么是二进制?
20.　23 什么是八进制?
20.　24 什么是十六进制?
20．25 什么是换码符(escape characters)?
第21章 windows
21．1 可以在windows程序中使用printf()吗?
21．2 怎样在windows程序中建立一个延时器?
21．3 什么是句柄?
21．4 怎样中止一个windows程序?
21．5 什么是gdi?通过什么途径使用它?
21．6 为什么windows．h很重要?
21．7 什么是windows sdk?
21．8 在编写windows程序时microsoft的windows sdk是必需的吗?
21．9 windows函数和标准dos函数有什么区别?
21．10 什么是动态连接?
21．11 handle，hwnd和hdc之间有什么区别?
21．12 windows程序对于不同的编译程序是兼容的吗?
21．13 windows总是保存和刷新程序的窗口吗?
21．14 怎样确定一个windows程序的用户区的大小?
21．15 什么是oem键码?
21．16 windows程序需要考虑oem键码吗?
21．17 什么是虚拟键码?
21．18 什么是死键?
21．19 插入标记(caret)和光标(cursor)有什么区别?
21．20 在程序用户区外撤击鼠标能被捕获到吗?
21．21 怎样创建一个活动的位图?
21．22 怎样在windows程序中获得日期和时间?
21．23 怎样在windows程序中更新标题条(titlebar)?
21．24 怎样在windows程序中获得系统颜色?
21．25 什么是系统颜色常量?
21．26 怎样创建自己的按钮或控制(controls)?
21．27 什么是静态子窗口(static child windows)?
21．28 怎样创建窗口子类(window subclassing)?
21．29 什么是编辑类(edit class)?
21．30 什么是列表框类(listbox class)?
21．31 windows是怎样组织内存的?
21．32 怎样在windows程序中分配内存?
21．33 模式(modal)对话框和非模式(modeless)对话框有什么区别?
索引
附录 标准库函数的头文件

[ 本帖最后由 tiankai001 于 2013-9-10 23:03 编辑 ]

tiankai001

微软-C语言编程精粹

目    录

序.................................................................................................................................... 4

命名约定.......................................................................................................................... 6

某些背景.......................................................................................................................... 7

引言................................................................................................................................. 8

第1章  假想的编译程序................................................................................................ 12

第2章  自己设计并使用断言......................................................................................... 20

第3章  为子系统设防................................................................................................... 45

第4章  对程序进行逐条跟踪......................................................................................... 68

第5章  糖果机界面....................................................................................................... 76

第6章  风险事业.......................................................................................................... 92

第7章  编码中的假象.................................................................................................. 116

第8章  剩下来的就是态度问题................................................................................... 134

附录A  编码检查表..................................................................................................... 149

附录B  内存登录例程.................................................................................................. 152

附录C  练习答案......................................................................................................... 160

后记   走向何方.......................................................................................................... 183

序  ………………………………………………………………………………  Ⅰ

某些背景  ………………………………………………………………………  Ⅲ

命名约定  ………………………………………………………………………  Ⅳ

引  言  …………………………………………………………………………  Ⅵ

第1章         假想的编译程序 ……………………………………………………   1

第2章         自己设计并使用断言 ………………………………………………   8

第3章         为子系统设防 ………………………………………………………  31

第4章         对程序进行逐条跟踪 ………………………………………………  53

第5章         糖果机界面 …………………………………………………………  60

第6章         风险事业 ……………………………………………………………  75

第7章         编码中的假象 ………………………………………………………  98

第8章         剩下的就是态度问题 ……………………………………………… 115

后  记         走向何方 …………………………………………………………… 129

附录A       编码检查表 …………………………………………………………… 130

附录B       内存登录例程 ………………………………………………………… 133

附录C       练习答案 ……………………………………………………………… 140

参考文献  ……………………………………………………………………… 160

[ 本帖最后由 tiankai001 于 2013-9-10 23:05 编辑 ]

tiankai001

C程序设计语言（第2版·新版）非扫描版&详细书签版


《C程序设计语言》（第2版新版）讲述深入浅出，配合典型例证，通俗易懂，实用性强，适合作为大专院校计算机专业或非计算机专业的C语言教材，也可以作为从事计算机相关软硬件开发的技术人员的参考书。《C程序设计语言》（第2版新版）原著即为C语言的设计者之一Dennis M.Ritchie和著名的计算机科学家Brian W.Kernighan合著的一本介绍C语言的权威经典著作。我们现在见到的大量论述C语言程序设计的教材和专著均以此书为蓝本。原著第1版中介绍的C语言成为后来广泛使用的C语言版本——标准C的基础。人们熟知的“hello，world”程序就是由本书首次引入的，现在，这一程序已经成为所有程序设计语言入门的第一课。

　《C程序设计语言》（第2版新版）是由C语言的设计者Brian W.Kernighan和Dennis M.Ritchie编写的一部介绍标准C语言及其程序设计方法的权威性经典著作。全面、系统地讲述了C语言的各个特性及程序设计的基本方法，包括基本概念，类型和表达式、控制流、函数与程序结构、指针与数组、结构、输入与输出、UNIX系统接口、标准库等内容。


出版者的话
专家指导委员会
中文版序
译者序
校译者简介
序
第1版序
引言
第1章 导言
1.1 入门
1.2 变量与算术表态式
1.3 for语句
1.4 符号常量
1.5 字符输入/输出
1.6 数组
1.7 函数
1.8 参数——传值调用
1.9 字符数组
1.10 外部变量与作用域
第2章 类型、运算符与表达式
2.1 变量名
2.2 数据类型及长度
2.3 常量
2.4 声明
2.5 算术运算符
2.6 关系运算符与逻辑运算符
2.7 类型转换
2.8 自增运算符与自减运算符
2.9 按位运算符
2.10 赋值运算符与表达式
2.11 条件表达式
2.12 运算符优先级与求值次序
第3章 控制流
3.1 语句与程序块
3.2 if-else语句
3.3 else-if语句
3.4 switch语句
3.5 whil循环与for特环
3.6 do-while循环
3.7 break语句与continue语句
3.8 goto语句与标号
第4章 涵数与程序结构
第5章 指针与数组
第6章 结构
第7章 输入与输出
第8章 UNIX系统接口
附录A 参考手册
附录B 标准库
附录C 变更小结
索引

[ 本帖最后由 tiankai001 于 2013-9-10 23:07 编辑 ]

tiankai001

C专家编程

《C和C++经典著作?C专家编程Expert C Programming Deep C Secrets》展示了最优秀的C程序员所使用的编码技巧，并专门开辟了一章对C++的基础知识进行了介绍。书中C的历史、语言特性、声明、数组、指针、链接、运行时、内存以及如何进一步学习C++等问题进行了细致的讲解和深入的分析。全书撷取几十个实例进行讲解，对C程序员具有非常高的实用价值。《C和C++经典著作?C专家编程Expert C Programming Deep C Secrets》可以帮助有一定经验的C程序员成为C编程方面的专家，对于具备相当的C语言基础的程序员，《C和C++经典著作?C专家编程Expert C Programming Deep C Secrets》可以帮助他们站在C的高度了解和学习C++。

第1章 C：穿越时空的迷雾
1.1 C语言的史前阶段
1.2 C语言的早期体验
1.3 标准I/O库和C预处理器
1.4 K&R C
1.5 今日之ANSI C
1.6 它很棒，但它符合标准吗
1.7 编译限制
1.8 ANSI C标准的结构
1.9 阅读ANSI C标准，寻找乐趣和裨益
1.10 “安静的改变”究竟有多少安静
1.11 轻松一下——由编译器定义的Pragmas效果

第2章 这不是Bug，而是语言特性
2.1 这关语言特性何事，在Fortran里这就是Bug呀
2.2 多做之过
2.3 误做之过
2.4 少做之过
2.5 轻松一下——有些特性确实就是Bug
2.6 参考文献

第3章 分析C语言的声明
3.1 只有编译器才会喜欢的语法
3.2 声明是如何形成的
3.3 优先级规则
3.4 通过图表分析C语言的声明
3.5 typedef可以成为你的朋友
3.6 typedef int x[10]和#define x int[10]的区别
3.7 typedef struct foo{ ... foo; }的含义
3.8 理解所有分析过程的代码段
3.9 轻松一下——驱动物理实体的软件

第4章 令人震惊的事实：数组和指针并不相同
4.1 数组并非指针
4.2 我的代码为什么无法运行
4.3 什么是声明，什么是定义
4.4 使声明与定义相匹配
4.5 数组和指针的其他区别
4.6 轻松一下——回文的乐趣

第5章 对链接的思考
5.1 函数库、链接和载入
5.2 动态链接的优点
5.3 函数库链接的5个特殊秘密
5.4 警惕Interpositioning
5.5 产生链接器报告文件
5.6 轻松一下——看看谁在说话：挑战Turing测验

第6章 运动的诗章：运行时数据结构
6.1 a.out及其传说
6.2 段
6.3 操作系统在a.out文件里干了些什么
6.4 C语言运行时系统在a.out里干了些什么
6.5 当函数被调用时发生了什么：过程活动记录
6.6 auto和static关键字
6.7 控制线程
6.8 setjmp和longjmp
6.9 UNIX中的堆栈段
6.10 MS-DOS中的堆栈段
6.11 有用的C语言工具
6.12 轻松一下——卡耐基-梅隆大学的编程难题
6.13 只适用于高级学员阅读的材料

第7章 对内存的思考
7.1 Intel 80x86系列
7.2 Intel 80x86内存模型以及它的工作原理
7.3 虚拟内存
7.4 Cache存储器
7.5 数据段和堆
7.6 内存泄漏
7.7 总线错误
7.8 轻松一下——“Thing King”和“页面游戏”

第8章 为什么程序员无法分清万圣节和圣诞节
8.1 Portzebie度量衡系统
8.2 根据位模式构筑图形
8.3 在等待时类型发生了变化
8.4 原型之痛
8.5 原型在什么地方会失败
8.6 不需要按回车键就能得到一个字符
8.7 用C语言实现有限状态机
8.8 软件比硬件更困难
8.9 如何进行强制类型转换，为何要进行类型强制转换
8.10 轻松一下——国际C语言混乱代码大赛

第9章 再论数组
9.1 什么时候数组与指针相同
9.2 为什么会发生混淆
9.3 为什么C语言把数组形参当作指针
9.4 数组片段的下标
9.5 数组和指针可交换性的总结
9.6 C语言的多维数组
9.7 轻松一下——软件/硬件平衡

第10章 再论指针
10.1 多维数组的内存布局
10.2 指针数组就是Iliffe向量
10.3 在锯齿状数组上使用指针
10.4 向函数传递一个一维数组
10.5 使用指针向函数传递一个多维数组
10.6 使用指针从函数返回一个数组
10.7 使用指针创建和使用动态数组
10.8 轻松一下——程序检验的限制

第11章 你懂得C，所以C++不在话下
11.1 初识OOP
11.2 抽象——取事物的本质特性
11.3 封装——把相关的类型、数据和函数组合在一起
11.4 展示一些类——用户定义类型享有和预定义类型一样的权限
11.5 访问控制
11.6 声明
11.7 如何调用成员函数
11.8 继承——复用已经定义的操作
11.9 多重继承——从两个或更多的基类派生
11.10 重载——作用于不同类型的同一操作具有相同的名字
11.11 C++如何进行操作符重载
11.12 C++的输入/输出(I/O)
11.13 多态——运行时绑定
11.14 解释
11.15 C++如何表现多态
11.16 新奇玩意——多态
11.17 C++的其他要点
11.18 如果我的目标是那里，我不会从这里起步
11.19 它或许过于复杂，但却是惟一可行的方案
11.20 轻松一下——死亡计算机协会
11.21 更多阅读材料

附录A 程序员工作面试的秘密
附录B 术语表

[ 本帖最后由 tiankai001 于 2013-9-10 23:08 编辑 ]

tiankai001

C语言参考手册

《c语言参考手册（原书第5版）》是c语言的详尽参考手册，分为两部分：第一部分讨论了c语言的所有语言特征，包括词法、预处理机制、声明、类型、表达式、语句以及函数等基本语言特征；第二部分讨论了c语言的标准库，针对它们不同的功能分别进行详细介绍。为了帮助读者理解相关概念，《c语言参考手册（原书第5版）》在讨论c语言及其标准库的细节时，提供了许多实例和解释。第一部分的各章还提供了练习题和主要练习的解答，这些练习可帮助读者加深理解c语言的基本功能和特性。
　　《c语言参考手册（原书第5版）》可以作为高等院校计算机专业c语言课程的教材和参考书，也可供程序开发人员参考。

译者序
前 言
第一部分 c语言
第1章 概述
1.1 c语言的演变
1.1.1 传统c
1.1.2 标准c（1989）
1.1.3 标准c（1995）
1.1.4 标准c（1999）
1.1.5 标准c++
1.1.6 《c语言参考手册（原书第5版）》内容
1.2 应该使用哪种c语言
1.3 c编程概述
1.4 一致性
1.5 语法约定
第2章 词法元素
2.1 字符集
2.1.1 执行字符集
2.1.2 空白字符和行终止符
2.1.3 字符编码
2.1.4 三字符组
2.1.5 多字节字符和宽字符
2.2 注释
2.3 标记
2.4 操作符和分隔符
2.5 标识符
2.6 关键字
2.7 常量
2.7.1 整数常量
2.7.2 浮点数常量
2.7.3 字符常量
2.7.4 字符串常量
2.7.5 转义字符
2.7.6 字符转义码
2.7.7 数值转义码
2.8 c++兼容性
2.8.1 字符集
2.8.2 注释
2.8.3 操作符
2.8.4 标识符和关键字
2.8.5 字符常量
2.9 关于字符集、指令集和编码
2.10 练习
第3章 c预处理器
3.1 预处理器命令
3.2 预处理器词法约定
3.3 定义和替换
3.3.1 类似对象的宏定义
3.3.2 定义带参数的宏
3.3.3 宏表达式的重新扫描
3.3.4 预定义的宏
3.3.5 取消宏定义和重新定义宏
3.3.6 宏展开的优先级错误
3.3.7 宏参数的副作用
3.3.8 把标记转换为字符串
3.3.9 宏展开中的标记合并
3.3.10 宏的可变参数列表
3.3.11 其他问题
3.4 文件包含
3.5 条件编译
3.5.1 #if、#else和#endif命令
3.5.2 #elif命令
3.5.3 #ifdef和#ifndef命令
3.5.4 条件命令中的常量表达式
3.5.5 defined操作符
3.6 显式的行号
3.7 pragma指令
3.7.1 标准pragma命令
3.7.2 标准pragma指令的位置
3.7.3 _pragma操作符
3.8 错误指令
3.9 c++兼容性
3.10 练习
第4章 声明
第5章 类型
第6章 转换和表示形式
第7章 表达式
第8章 语句
第9章 函数
第二部分 c函数库
第10章 函数库简介
第11章 标准语言附加
第12章 字符处理
第13章 字符串处理
第14章 内存函数
第15章 输入/输出工具
第16章 基本工具
第17章 数学函数
第18章 时间和日期函数
第19章 控制函数
第20章 区域
第21章 扩展整数类型
第22章 浮点环境
第23章 复数运算
第24章 宽字符和多字节字符工具
附录a ascii字符集
附录b 语法
附录c 练习答案

[ 本帖最后由 tiankai001 于 2013-9-10 23:09 编辑 ]

tiankai001

C语言接口与实现--创建可重用软件的技术

《C语言接口与实现：创建可重用软件的技术》可重用的软件模块是构建大规模可靠应用程序的基石，创建可重用的软件模块是每个程序员和项目经理必须掌握的技能。C语言对创建可重用的API提供的语言和功能支持非常少，虽然C程序员写应用时都会用到API和库，但却很少有人去创建和发布新的能广泛应用的API。《C语言接口与实现：创建可重用软件的技术》介绍用一种基于接口的设计方法创建可重用的API，这一方法将接口与实现分离开来，且与语言无关。书中详细描述了T24个接口及其实现，便于读者深入了解此方法。这些接口涉及很多计算机领域的知识，包括数据结构、算法、字符串处理和并发程序。
    《C语言接口与实现：创建可重用软件的技术》是C语言领域的经典名著，出版十余年仍畅销不衰，是几代程序员倍加推崇的力作。
    《C语言接口与实现：创建可重用软件的技术》特色：接口描述简单明了，程序员可将此书用作相关接口的参考手册，深入剖析如何将数据结构及其相关算法打包成可重用的模块，分析了全部24个API和8个示例应用的源代码，揭秘了许多鲜有文档的C语言编程技巧。


《C语言接口与实现：创建可重用软件的技术》概念清晰、实例详尽，是一本有关设计、实现和有效使用C语言库函数，掌握创建可重用C语言软件模块技术的参考指南。书中提供了大量实例，重在阐述如何用一种与语言无关的方法将接口设计实现独立出来，从而用一种基于接口的设计途径创建可重用的API。
    《C语言接口与实现：创建可重用软件的技术》是所有C语言程序员不可多得的好书，也是所有希望掌握可重用软件模块技术的人员的理想参考书，适合各层次的面向对象软件开发人员、系统分析员阅读。


第1章 引言
1.1 文学程序
1.2 程序设计风格
1.3 效率
1.4 扩展阅读
1.5 习题

第2章 接口与实现
2.1 接口
2.2 实现
2.3 抽象数据类型
2.4 客户程序的职责
2.5 效率
2.6 扩展阅读
2.7 习题

第3章 原子
3.1 接口
3.2 实现
3.3 扩展阅读
3.4 习题

第4章 异常与断言
4.1 接口
4.2 实现
4.3 断言
4.4 扩展阅读
4.5 习题

第5章 内存管理
5.1 接口
5.2 产品实现
5.3 稽核实现
5.4 扩展阅读
5.5 习题

第6章 再谈内存管理
6.1 接口
6.2 实现
6.3 扩展阅读
6.4 习题

第7章 链表
7.1 接口
7.2 实现
7.3 扩展阅读
7.4 习题

第8章 表
8.1 接口
8.2 例子：词频
8.3 实现
8.4 扩展阅读
8.5 习题

第9章 集合
9.1 接口
9.2 例子：交叉引用列表
9.3 实现
9.3.1 成员操作
9.3.2 集合操作
9.4 扩展阅读
9.5 习题

第10章 动态数组
10.1 接口
10.2 实现
10.3 扩展阅读
10.4 习题

第11章 序列
11.1 接口
11.2 实现
11.3 扩展阅读
11.4 习题

第12章 环
12.1 接口
12.2 实现
12.3 扩展阅读
12.4 习题

第13章 位向量
13.1 接口
13.2 实现
13.2.1 成员操作
13.2.2 比较
13.2.3 集合操作
13.3 扩展阅读
13.4 习题

第14章 格式化
14.1 接口
14.1.1 格式化函数
14.1.2 转换函数
14.2 实现
14.2.1 格式化函数
14.2.2 转换函数
14.3 扩展阅读
14.4 习题

第15章 低级字符串
15.1 接口
15.2 例子：输出标识符
15.3 实现
15.3.1 字符串操作
15.3.2 分析字符串
15.3.3 转换函数
15.4 扩展阅读
15.5 习题

第16章 高级字符串
16.1 接口
16.2 实现
16.2.1 字符串操作
16.2.2 内存管理
16.2.3 分析字符串
16.2.4 转换函数
16.3 扩展阅读
16.4 习题

第17章 扩展精度算术
17.1 接口
17.2 实现
17.2.1 加减法
17.2.2 乘法
17.2.3 除法和比较
17.2.4 移位
17.2.5 字符串转换
17.3 扩展阅读
17.4 习题

第18章 任意精度算术
18.1 接口
18.2 例子：计算器
18.3 实现
18.3.1 取反和乘法
18.3.2 加减法
18.3.3 除法
18.3.4 取幂
18.3.5 比较
18.3.6 便捷函数
18.3.7 移位
18.3.8 与字符串和整数的转换
18.4 扩展阅读
18.5 习题

第19章 多精度算术
19.1 接口
19.2 例子：另一个计算器
19.3 实现
19.3.1 转换
19.3.2 无符号算术
19.3.3 有符号算术
19.3.4 便捷函数
19.3.5 比较和逻辑操作
19.3.6 字符串转换
19.4 扩展阅读
19.5 习题

第20章 线程
20.1 接口
20.1.1 线程
20.1.2 一般信号量
20.1.3 同步通信通道
20.2 例子
20.2.1 并发排序
20.2.2 临界区
20.2.3 生成素数
20.3 实现
20.3.1 同步通信通道
20.3.2 线程
20.3.3 线程创建和上下文切换
20.3.4 抢占
20.3.5 一般信号量
20.3.6 MIPS和ALPHA上的上下文切换
20.4 扩展阅读
20.5 习题
附录A 接口摘要
参考书目

[ 本帖最后由 tiankai001 于 2013-9-10 23:10 编辑 ]

tiankai001

C陷阱与缺陷

作者以自己1985年在Bell实验室时发表的一篇论文为基础，结合自己的工作经验扩展成为这本对C程序员具有珍贵价值的经典著作。写作本书的出发点不是要批判C语言，而是要帮助C程序员绕过编程过程中的陷阱和障碍。
    全书分为 8章，分别从词法分析、语法语义、连接、库函数、预处理器、可移植性缺陷等几个方面分析了C编程中可能遇到的问题。最后，作者用一章的篇幅给出了若干具有实用价值的建议。
    本书适合有一定经验的C程序员阅读学习，即便你是C编程高手，本书也应该成为你的案头必备书籍。


第0章  导读  1
第1章  词法“陷阱”  5
1.1  =不同于==  6
1.2  & 和 | 不同于&& 和 ||  8
1.3  词法分析中的“贪心法”  8
1.4  整型常量  10
1.5  字符与字符串  11
第2章  语法“陷阱”  15
2.1  理解函数声明  15
2.2  运算符的优先级问题  19
2.3  注意作为语句结束标志的分号  24
2.4  switch语句  26
2.5  函数调用  28
2.6  “悬挂”else引发的问题  29
第3章  语义“陷阱”  33
3.1  指针与数组  33
3.2  非数组的指针  39
3.3  作为参数的数组声明  41
3.4  避免“举隅法”  43
3.5  空指针并非空字符串  44
3.6  边界计算与不对称边界  45
3.7  求值顺序  57
3.8  运算符&&、|| 和 !  59
3.9  整数溢出  61
3.10  为函数main提供返回值  62
第4章  连接  65
4.1  什么是连接器  65
4.2  声明与定义  67
4.3  命名冲突与static修饰符  69
4.4  形参、实参与返回值  70
4.5  检查外部类型  77
4.6  头文件  80
第5章  库函数  83
5.1  返回整数的getchar函数  84
5.2  更新顺序文件  85
5.3  缓冲输出与内存分配  86
5.4  使用errno检测错误  88
5.5  库函数signal  89
第6章  预处理器  93
6.1  不能忽视宏定义中的空格  94
6.2  宏并不是函数  94
6.3  宏并不是语句  99
6.4  宏并不是类型定义  101
第7章  可移植性缺陷  103
7.1  应对C语言标准变更  104
7.2  标识符名称的限制  106
7.3  整数的大小  107
7.4  字符是有符号整数还是无符号整数  108
7.5  移位运算符  109
7.6  内存位置0  110
7.7  除法运算时发生的截断  111
7.8  随机数的大小  113
7.9  大小写转换  113
7.10  首先释放，然后重新分配  115
7.11  可移植性问题的一个例子  116
第8章  建议与答案  121
8.1  建议  122
8.2  答案  126
附录A  PRINTF，VARARGS与STDARG  145
附录B  Koenig和Moo夫妇访谈  167

[ 本帖最后由 tiankai001 于 2013-9-10 23:11 编辑 ]

tiankai001

C大学教程(第五版)]


全面面权威地受用DEITEL活动代码方法介绍C语言，并且大量地介绍C++面向对象程序设计（OOP）！
　　C语言是全球最流行的程序设计语言之一。本版全球最畅销的C语言教程介绍了四种当流行的程序设计方法——面向过程、基于对象、面向对象以及泛型编程。
　　我从1975年开始讲授入门级程序设计课程，从1986年开始用c语言编程。最初，没有比较优秀的c语言教程。当 Deitel的《c大学教程（第一版）问世之后，人们争先购买这本书。显然，它是当时最优秀的c语言教程。这版新书仍然继承了遗一传统，是当今最优秀的面向学生的c语言程序设计教程。Deitel父子再次设定了优秀教材的标准!不但透彻、仔细地向学生讲解编程语言，而且更加注重思想、概念以及程序设计技术。新加八的“活代码”方法也是一大新增特色，促进学生积极地参与到程序设计中来。这是一本非常出色的教材!
　　——Richard Albright，Goldey-Beacom学院
　　《c大学教程》（第五版）继保持了优秀的c语言教程这一传统。该书从简单的概念到最终完整的语言描述，清晰、准确地向初学者展示c语言。语言的讲解非常完整，使得这本书也同样适用于有经验的程序员，本书新增加了基于Allegro C函数库的游戏编程章节，也同样会吸引很多青少年程序设计人员。这是一本杰出的c程序员教程与参考书。
　　——Ray Seyfarth，Southern Mississippi大学
　　这是一本优秀的面向初学者的书籍。同样涵盖了适用于高级程序设计课程以及工作市场的内容。
　　——Fred J.Tydeman，Tydeman咨询公司，JLL（ANSI“C”）副总裁
　　在市场上众多c语言教程中，Deitel书籍最清晰、最深入地向学生讲授标准c程序设计的各项技能。使用Deitel撰写的c语言教程，学生可以获得大量的资源，帮助他们不但在学习上取得成功+而且在将来的工作中也取得成功。
　　——William Smith，Tulsa Community学院


本书是全球最畅销的C语言教程之一。本书系统地介绍了四种当今流行的程序设计方法——面向过程、基于对象、面向对象以及泛型编程，内容全面、生动、易懂，作者由浅入深地介绍结构化编程及软件工程的基本概念，从简单的概念到最终完整的语言描述，清晰、准确、透彻、详细地讲解C语言，尤其注重程序设计思想和方法的介绍。相对于以往的版本，在内容方面，本书新增加了介绍C99标准、排序、基于Allegro C函数库的游戏编程以及有关C++面向对象程序设计的章节，并且在附录中增加了Sudoku游戏程序设计的讲解。新加入的“活代码”方法（即通过可执行的代码来讲解理论概念的方法）是本书的另一特色，它可以促进学生积极地参与到程序设计中来。突出显示的各种程序设计提示，则是作者多年教学经验的总结。
　　本书不仅适合于初学者学习，作为高校计算机程序设计教学的教科书，也同样适用于有经验的程序员，作为软件开发人员的专业参考书。


第1章  计算机、Internet和万维网导论
第2章  C语言程序设计入门
第3章  结构化的C程序设计
第4章  C程序控制
第5章  C函数
第6章  C数组
第7章  C指针
第8章  C字符和字符串
第9章  格式化输入输出
第10章  结构体、共用体、位操作和枚举类型
第11章  文字处理
第12章  数据结构
第13章  C预处理
第14章  C语言的其他专题
第15章  基于Allegro C函数库的游戏编程
第16章  排序：更深入的透视
第17章  C99简介
第18章  C++，一个更好的C；介绍对象技术
第19章  类与对象简介
第20章  类；深入剖析（第1部分）
第21章  类；深入剖析（第2部分）
第22章  运算符重载
第23章  面向对象编辑：继承
第24章  面向对象编程：多态
第25章  模板
第26章  输入/输出
第27章  异常处理
附录A　因特网和Web资源
附录B　运算符优先级表
附录C　ASCLL字符集
附录D　数制系统
附录E　游戏编程：求解Sudoku问题
索引

[ 本帖最后由 tiankai001 于 2013-9-10 23:13 编辑 ]