我们编程吧

C语言入门经典--学习笔记

C语言入门经典(Beginning C From Novice To Professional) 第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 输入输出格式指定符

王爽-汇编语言汇编语言_第2版 汇编语言是各种CPU提供的机器指令的助记符的集合，人们可以用汇编语言直接控制硬件系统进行工作。汇编语言是很多相关课程(如数据结构、操作系统、微机原理等)的重要基础。为了更好地引导、帮助读者学习汇编语言，作者以循序渐进的思想精心创作了这本书。本书具有如下特点：采用了全新的结构对课程的内容进行组织，对知识进行最小化分割，为读者构造了循序渐进的学习线索；在深入本质的层面上对汇编语言进行讲解；对关键环节进行深入的剖析。

用GTK+和GDK开发Linux图形用户界面应用

vim中的移动技巧，包括字移动、行移动、段落移动，快速定位到行首位、文档的首尾。

libwdapi910.so关于Mark5的驱动静态链接库。

Mark5C Software Development

打造C程序员专用vim 打造C程序员专用vim ctagc,taglist,cvim,cscope

Vim 101 Hacks eBook包含101个关于各种高级Vim特性的实际例子，这些例子让你用起Vim来游刃有余。

The.Definitive.Guide.to.GCC.2nd.Edition.2006.pdf Debugging+With+Gdb,+9Th+Ed.pdf Learning_GNU_Emacs_Third_Edition.chm Linux.Commands.Editors.and.Shell.Programming.chm Managing+Projects+with+GNU+Make.pdf O'Reilly.Bash.Cookbook.May.2007.pdf Prentice.Hall.Linux.Debugging.and.Performance.Tuning.Tips.and.Techniques.chm 本人一直都在UNIX下从事嵌入式的开发工作,也深知老祖宗说的:工欲善其事必先利其器的道理.这些书籍涵盖了从vi,emacs(编辑器), gcc(编译器), make(工程项目管理), gdb(调试),bash(使用最广泛的shell)等unix环境下开发所需的大部分工具的基本使用和高级功能等.基本上是某方面最经典最权威的著作.如Debugging+With+Gdb,+9Th+Ed.pdf就为Richard Stallman等亲自所写. Emacs,GCC,Make,GDB,Bash

12本精彩的Linux书籍 1. Sed and Awk，作者Dale Dougherty and Arnold Robbins。这本书改变了我在Linux命令行下的工作方式。这本书可能是你学习Sed和Awk时唯一需要的参考资料。一旦你掌握了Sed和Awk的基础，你就会着迷于能够快速并且高效的完成一系列复杂工作。我平常用于sed 和awk的参考的是由相同作者所著的《Sed and Awk Pocket Reference》。 2. HULearning The Vi and Vim EditorUH，作者Arnold Robbins。 我对于命令行下的操作情有独钟。因此，自然地我非常喜欢Vi 和 Vim 进行文本编辑。回首数年之前，当我需要在Linux下写大量的C程序的代码时，我总会参考Vi文本编辑器的快速参考手册。即使你已经用了很长时间的Vi和vim编辑器，如果你没有读过这本书的话，那么请你读一下这本书。你会惊讶于Vim编辑器的强大功能。 3. HUBash CookbookU ，作者Carl Albing, JP Vossen and Cameron Newham。无论你是系统管理员还是数据库管理员，或者是个开发人员，你都会或多或少的写些shell脚本。聪明的系统管理员都知道掌握了shell脚本编程之后，可以让shell脚本作一些微小繁杂的工作，从而使你的服务器处于自动运行状态。要达到这种境界，你就需要掌握本书中所举出的例子。市面上这方面的书籍相当的多，但这本书以丰富细致的实例而完全超越它们。 4. HUSSH,The Secure Shell U，作者Daniel J. Barrett, Richard E. Silverman and Robert G。Byrnes。这无疑是关于SSH方面最好的书了。这本书介绍了SSH的理论和实践的各个方面。作为最终用户使用SSH是相当方便的。但是作为一个管理员配置SSH相对来讲比较复杂，同时要对SSH有更深的理解。对于每个系统管理员，这本书都是必读书籍。这本书中的例子直接给出了该如何根据需求(SHH1,SHH2和OpenSSH)来量身定制SSH的不同口味。 5. HUEssential System AdministratorUH，作者Æleen Frisch。对于想成为UNIX系统管理员的人来说 这是一本相当棒的书。这本书囊括了所有的系统管理工作。很好得整合了AIX,FreeBSD, HP-UX，Linux,Solaris 和Tru64等多种UNIX版本。所有当你在处理不同版本的UNIX时，它是个不错的参考。以前当我同时管理多种UNIX系统时候就用了这本书的便携版----Essential System Administration Pocket Reference。 6. HULinux Server HacksUH，卷一，作者Rob Flickenger。这本书中收藏了100相当不错的技巧。搭建一个Linux实验平台并且一一测试这些技巧。这些技巧被分成了不同的章节—服务器基础、版本控制、备份、网络、监控、SSH、脚本和数据服务器。当你完全读懂Linux Server Hacks，就可以掌握了这些技巧；卷二，作者Willian von Hagen 和 Brian Jones。这本书也包含了100个技巧，集中在认证,监控,安全,性能和连通性。 7. HUDNS and BINDUHU，作者Cricket Liu 和 Paul Albitz。几年前我通过阅读在线文档第一次配置了DNS. 本着了解DNS 和 BIND 是如何工作的目的，我买了这本书。之后它的版本又更新了两次，每次我都购买了新版本。如果你是个认真的系统管理员，这本书应该在你的书库里。 8. HUUnderstanding the Linux KernelUH，作者Daniel Bovet 和 Marco Cesati。如果你是一个Linux环境下的开发人员或者系统管理员，那么这本书是必读的。这本书以一种结构化且符合逻辑的方式阐述了Linux 2.6内核的工作原理。这本书介绍了内核的内存管理，进程调度， I/O架构以及块设备管理等内容。这本书是为那些想深入了解Linux的Geek们而量身打造的。 9. HULinux CookbookUH，作者Carla Schroder。这本书分别以用户和管理员的角度阐释Linux的各种特性。其中两个章节介绍了如何在基于RPM的系统以及Debian下安装和管理软件。如果你使用的是RedHat，由Daniel J. Barrett所写，包括了Linux命令的所有示例用法的《the Linux Pocker Guide》对你来说将会是个不错的选择。 10.HULinux FirewallsUH，作者Michael Rash。如果想要建立一个安全的Linux系统，那么这本书是必读的。关于防火墙有很多相关书籍。但是这本书详述了如何用防火墙，psad, fwsnort配置一个入侵检测系统。如果你想要一本有关防火墙的详细参考，那么由Gregory N. Purdy 所著的《Linux Iptables Pocket Reference》将是你的最佳选择。 11.HULinux Administration HandbookUH，作者Evi Nemeth， Garth Snydet 和 Trent R. Hein。早年，在我做系统程序员的时候，我经常参考这本书。这是一本相当非常详细的书，分成了三章Basic Administration， Networking 和 Bunch O’Stuff， 共有将近1000页，30节。 12.HUBeginning Ubuntu LinuxUH，作者Keir Thomas 和 Jaime Sicam。对于那些想从Windows转向Linux并在自己的老机器上安装Ubuntu的人，这本书就是你所需要的。我坚信这本书可以将Linux的信息介绍给那些不用Linux的人。如果你想要你的密友或朋友学习Linux系统的话，那么装上Ubuntu并用把这本书作为礼物送给他，那么他一定会非常感激你的。

c++学好c++必须的十本书籍：该资源包含一下内容。。 Essential C++ 中文版 C++ Primer中文版（第4版）（特别版） Effective C++：改善程序技术与设计思维的55个有效做法（第三版）（中文版） C++ 编程思想 More Effective C++中文版 Exceptional C++中文版 More Exceptional C++中文版 Exceptional C++ Style中文版 深度探索C++对象模型 C++沉思录

GNU_Autoconf_Automake_Libtool

data_structures_and_algorithms_with_object_oriented_design_patterns_in_cpp

POSIX多线程程序设计中文版 此书为POSIX多线程程序设计中文版。本书深入描述了IEEE的开放系统接口标准-POSIX线程，通常称为Ptherads标准。本书首先解释了线程的基本概念，包括异步编程、线程的生命周期和同步机制；然后讨论了题，并给出了避免错误和提高性等问题的有价值的建议。本书使用了大量注释过的实例来解释实际的概念，并包括Pthreads的简装索引和对标准化的展望。本书适合有经验的C语言程序员阅读，也适合多线程编程人员参考。 -This book describes in depth the open system interface standard IEEE-POSIX threads, commonly known as Ptherads standards. This book first explains the basic concepts of threads, including asynchronous programming, thread life cycle and synchronization mechanisms and then discuss the topic, and gives avoiding mistakes and issues such as Ti Gao Xing valuable suggestions. This book uses a lot of comments over the examples to explain the concept of reality, and includes a slimmed-down Pthreads standard index and on the prospects. Book for experienced C language programmers to read, also suitable for multi-threaded programming for reference.

软考下半年试题分析与解答 内容简介 本书按照人力资源和社会保障部、工业和信息化产业部全国计算机技术与软件专业技术资格(水平)考试要求编写，书中详尽分析与解答了2008下半年的试题，包括12个级别。其中，高级资格有信息系统项目管理师和系统分析师；中级资格有软件设计师、网络工程师、信息系统监理师、电子商务设计师、嵌入式系统设计师和多媒体应用设计师；初级资格有程序员、网络管理员、信息处理技术员和电子商务技术员。 应试者通过学习本书的内容，可以熟悉这种考试的题型、试题的深度和广度、知识点分布情况，可以具体了解考试大纲的要求，还可以检验考生的能力。本书适合作为参加全国计算机软件考试的考生的学习用书，同时对从事计算机教学工作的教师、计算机工程技术人员也有帮助。 目录 第1章 程序员上午试题分析与解答 第2章 程序员下午试题分析与解答 第3章 网络管理员上午试题分析与解答 第4章 网络管理员下午试题分析与解答 第5章 信息处理技术员上午试题分析与解答 第6章 信息处理技术员上机考试试题分析与解答 第7章 电子商务技术员上午试题分析与解答 第8章 电子商务技术员下午试题分析与解答 第9章 软件设计师上午试题分析与解答 第10章 软件设计师下午试题分析与解答 第11章 网络工程师上午试题分析与解答 第12章 网络工程师下午试题分析与解答 第13章 信息系统监理师上午试题分析与解答 第14章 信息系统监理师下午试题分析与解答 第15章 电子商务设计师上午试题分析与解答 第16章 电子商务设计师下午试题分析与解答 第17章 嵌入式系统设计师上午试题分析与解答 第18章 嵌入式系统设计师下午试题分析与解答 第19章 多媒体应用设计师上午试题分析与解答 第20章 多媒体应用设计师下午试题分析与解答 第21章 信息系统项目管理师上午试题分析与解答 第22章 信息系统项目管理师下午试题分析与解答 第23章 信息系统项目管理师论文试题写作要点 第24章 系统分析师上午试题分析与解答 第25章 系统分析师下午试题Ⅰ分析与解答 第26章 系统分析师下午试题Ⅱ分析与解答

程序员考试辅导 内容简介 　　本书是根据中国计算机技术及软件专业技术资格（水平）考试2004年《程序员考试大纲》的要求，参照《程序员教程》的结构及历年软件专业资格考试试题编写的，内容紧扣考试大纲。全书共分12章，每章都由内容提要、例题分析、思考练习题组成。内容提要是对有关章节知识的提练，给出考试要点和学习难点。例题分析是全书重点，着重解析考试大纲要求的基本知识及其综合应用方法。思考练习题供读者检验自己对有关内容掌握的程度。为了帮助学员提高理解程序、编制程序及软件设计的能力，本书专门增加了C/C++ 语言程序设计一章，并在有关章节中加大了软件工程、数据结构和常用算法设计方法的比重。 　　本书供参加“程序员资格考试”的学员应试复习时使用，也可供大专院校及相应层次的计算机技术人员学习参考。 目录 　　第1章 计算机系统基础知识 　　1.1 内容提要 　　1.1.1 计算机基本组成和特性 　　1.1.2 数据表示 　　1.1.3 算术运算和逻辑运算 　　1.1.4 计算机组成原理 　　1.1.5 指令系统 　　1.1.6 计算机系统性能评价 　　1.2 例题分析 　　1.2.1 计算机的基本组成和特性 　　1.2.2 数据表示方法 　　1.2.3 运算方法 　　1.2.4 计算机组成原理 　　1.2.5 指令系统 　　1.2.6 计算机系统性评价 　　1.3 思考练习题及答案 　　思考练习题 　　思考练习题答案 　　第2章 操作系统基础知识 　　2.1 内容提要 　　2.1.1 操作系统内核与处理机管理 　　2.1.2 存储管理 　　2.1.3 文件管理 　　2.1.4 设备管理 　　2.1.5 作业管理与用户界面 　　2.2 例题分析 　　2.2.1 操作系统内核与处理机管理 　　2.2.2 存储管理 　　2.2.3 文件管理 　　2.2.4 设备管理 　　2.2.5 作业管理 　　2.3 思考练习题及答案 　　思考练习题 　　思考练习题答案 　　第3章 数据库基础知识 　　3.1 内容提要 　　3.1.1 数据库管理系统的功能和特征 　　3.1.2 数据库管理技术的发展 　　3.1.3 数据描述 　　3.1.4 数据模型 　　3.1.5 数据库系统的结构 　　3.1.6 关系模型和关系运算 　　3.1.7 关系数据库SQL语言简介 　　3.1.8 数据库设计过程 　　3.2 例题分析 　　3.3 思考练习题及答案 　　思考练习题 　　思考练习题答案 　　第4章 多媒体基础知识 　　4.1 内容提要 　　4.1.1 多媒体的概念 　　4.1.2 多媒体计算技术 　　4.1.3 多媒体存储技术 　　4.1.4 多媒体网络应用 　　4.1.5 多媒体内容编辑语言 　　4.2 例题分析 　　4.2.1 多媒体的概念 　　4.2.2 多媒体计算技术 　　4.2.3 多媒体存储技术 　　4.2.4 多媒体网络应用 　　4.2.5 多媒体内容编辑语言 　　4.3 思考练习题及答案 　　思考练习题 　　思考练习题答案 　　第5章 网络基础知识 　　…… 　　第6章 程序设计语言基础 　　第7章 系统开发与运行 　　第8章 数据结构 　　第9章 常用算法设计方法 　　第10章 标准化基础知识 　　第11章 知识产权基础知识 　　第12章 C/C++语言程序设计

精通MATLAB.7_0 内容简介 　　 本书基于最新的matlab7.x版本，深入浅出，紧密结合实例，对matlab的使用进行了全面且详尽的阐述，并通过大量的实例讲述了如何实现 matlab7.x的基本操作和实际使用。全书图文并茂，突出应用，并配有大量的程序实例。全书共分37章进行展开，分为基础篇和实战篇。基础篇为前面的 34章，主要讲述matlab的基本使用，分别为：基础入门、matlab桌面、数组及其操作、多维数组及其操作、数据类型概述和数值类型、结构体和元胞数组、字符串、关系运算和逻辑运算、程序控制流、函数、m文件调试和剖析、目录管理和文件i/o、matlab中的时间、矩阵代数、数据分析、数据插值、多项式、三次样条、傅里叶分析、最优化计算、微积分、常微分方程、二维图形、三维图形、使用颜色和光影、图像、声音和视频、图形的打印和导出、句柄图形、图形用户界面（gui）、matlab类和面向对象编程、matlab编程接口、扩展matlab和java、windows应用程序集成、 simulink交互式仿真集成环境。实战篇为后面的3章，主要讲述matlab综合应用的实例，分别为：matlab高等数学计算实例、matlab图形绘制实例、matlab扩展编程实例。 本书适合matlab的初、中级读者，可作为高等学校数学、计算机、电子工程、信息工程及相关专业师生的matlab使用参考手册，也可作为广大工程应用人员和开发人员不可多得的参考资料。 目录: 第1章 基础入门 1 1.1 matlab发展历程 1 1.2 matlab系统结构 2 1.3 matlab 7工具箱 3 1.4 matlab 7/simulink 6最新特点 4 1.4.1 matlab 7最新特点 4 1.4.2 simulink 6最新特点 5 1.5 matlab启动和退出 6 1.6 matlab基本特色 7 1.6.1 常量与变量 7 1.6.2 matlab基本运算 9 1.6.3 matlab基本函数 10 1.6.4 向量 11 1.7 小结 12 第2章 matlab桌面 13 2.1 matlab主菜单及功能 13 2.2 matlab 命令窗口 17 2.3 matlab工作空间 18 2.4 matlab文件管理 19 2.5 matlab帮助使用 19 2.5.1 直接使用help获得指令使用说明 20 2.5.2 直接使用help进行分类搜索 20 2.5.3 直接使用help获得具体子类指令说明 21 2.5.4 使用lookfor指令 21 2.6 小结 21 第3章 数组及其操作 22 3.1 matlab中的数组 22 3.2 数组的创建 23 3.2.1 创建空数组 23 3.2.2 创建一维数组 23 3.2.3 创建二维数组 24 3.3 数组属性 25 3.3.1 数组结构 25 3.3.2 数组大小 26 3.3.3 数组维度 27 3.3.4 数组数据类型 28 3.3.5 数组的内存占用 29 3.4 创建特殊数组 29 3.4.1 0-1数组 29 3.4.2 对角数组 30 3.4.3 随机数组 31 3.4.4 魔方数组 32 3.5 数组操作 32 3.5.1 数组的保存和装载 32 3.5.2 数组索引和寻址 33 3.5.3 数组的扩展和裁剪 35 3.5.4 数组形状的改变 42 3.5.5 数组运算 45 3.5.6 数组查找 49 3.5.7 数组排序 50 3.6 小结 52 第4章 多维数组及其操作 53 4.1 多维数组 53 4.1.1 多维数组的创建 53 4.1.2 多维数组的属性 56 4.2 多维数组的操作 56 4.2.1 多维数组的索引 56 4.2.2 多维数组的维度操作 57 4.2.3 多维数组参与数学计算 59 4.3 小结 60 第5章 数据类型概述和数值类型 61 5.1 matlab数据类型概述 61 5.2 matlab中的数值类型 62 5.2.1 整数类型 62 5.2.2 浮点数类型 65 5.2.3 复数 68 5.2.4 无穷量(inf)和非数值量(nan) 69 5.3 数值类型的显示格式 70 5.4 matlab中确定数值类型的函数 70 5.5 小结 71 第6章 结构体和元胞数组 72 6.1 结构体 72 6.1.1 结构体的创建 73 6.1.2 获取结构体内部数据 75 6.1.3 结构体数组操作函数 77 6.1.4 结构体嵌套 78 6.1.5 动态字段 79 6.1.6 结构体函数 79 6.2 元胞数组 80 6.2.1 元胞数组的创建 81 6.2.2 元胞数组的显示 82 6.2.3 元胞数组的操作 83 6.2.4 嵌套元胞数组 85 6.2.5 元胞数组函数 86 6.3 小结 87 第7章 字符串 88 7.1 创建字符串 88 7.1.1 单行字符串创建 88 7.1.2 多行字符串创建 89 7.2 字符串操作 90 7.2.1 字符串比较 90 7.2.2 字符串的替换和查找 92 7.2.3 其他操作 94 7.3 字符串的元胞数组 96 7.4 使用正则表达式搜索 98 7.5 字符数组和数值数组间的相互转换 99 7.6 小结 101 第8章 关系运算和逻辑运算 102 8.1 逻辑类型的数据 102 8.2 关系运算 103 8.3 逻辑运算 104 8.3.1 逐个元素的逻辑运算 104 8.3.2 捷径逻辑运算 106 8.3.3 逐位逻辑运算 107 8.4 逻辑函数和测试函数 108 8.5 运算优先级 110 8.6 小结 111 第9章 程序控制流 112 9.1 分支控制语句 112 9.1.1 if，else和elseif 112 9.1.2 switch，case和otherwise 114 9.2 循环控制语句 115 9.2.1 for循环 115 9.2.2 while循环 117 9.2.3 continue语句 117 9.2.4 break语句 118 9.2.5 数组结构和循环的效率比较 119 9.3 错误控制的try-catch结构 119 9.4 程序终止的return语句 120 9.5 小结 121 第10章 函数 122 10.1 m文件和matlab 10.1 编程概述 122 10.1.1 m文件概述 122 10.1.2 matlab编程概述 123 10.2 m文件结构和实例 124 10.2.1 m文件的一般结构 124 10.2.2 脚本m文件实例 125 10.2.3 函数m文件 127 10.3 函数类型 129 10.3.1 匿名函数 129 10.3.2 m文件主函数 130 10.3.3 嵌套函数 130 10.3.4 子函数 131 10.3.5 私有函数 132 10.3.6 重载函数 132 10.4 参数传递 132 10.4.1 matlab参数传递概述 132 10.4.2 输入和输出参数的数目 133 10.4.3 可变数目的参数传递 134 10.4.4 返回被修改的输入参数 135 10.4.5 全局变量 136 10.5 函数句柄 137 10.5.1 函数句柄的创建和调用 137 10.5.2 处理函数句柄的函数 138 10.6 小结 138 第11章 m文件调试和剖析 140 11.1 m文件调试工具 140 11.2 m文件分析工具 142 11.2.1 m-lint分析工具 143 11.2.2 profiler分析工具 144 11.3 小结 146 第12章 目录管理和文件i/o 147 12.1 当前目录和目录管理 147 12.1.1 当前目录工具条 147 12.1.2 当前目录面板 148 12.1.3 可视化目录显示 149 12.1.4 当前目录设置 150 12.1.5 命令窗口目录操作命令 151 12.2 matlab搜索路径 152 12.2.1 matlab文件运行搜索过程 152 12.2.2 搜索路径设置 153 12.2.3 搜索路径设置命令 153 12.3 文件管理 154 12.3.1 文本数据 154 12.3.2 图形、音频和视频数据 154 12.3.3 电子表格数据 154 12.3.4 科学标准格式数据 155 12.3.5 数据导入向导 155 12.3.6 因特网文件处理 156 12.3.7 低级文件i/o 156 12.4 小结 157 第13章 matlab中的时间 158 13.1 日期和时间 158 13.1.1 日期时间的三种表示格式 158 13.1.2 获取当前日期时间的函数 159 13.1.3 日期格式转换 160 13.1.4 datestr转换函数输出样式控制 160 13.2 程序中应用的计时函数 161 13.3 小结 162 第14章 矩阵代数 163 14.1 矩阵分析 163 14.1.1 矩阵的行列式 163 14.1.2 矩阵的逆 164 14.1.3 矩阵的秩 165 14.1.4 矩阵的范数和条件数 165 14.1.5 矩阵的特征值、特征向量和特征多项式 166 14.1.6 矩阵的标准正交基 167 14.1.7 矩阵分解 167 14.1.8 矩阵的对角元素操作 171 14.1.9 矩阵分析函数总结 172 14.2 线性方程组 173 14.2.1 线性方程组的表示和种类 173 14.2.2 线性方程组的matlab求解 174 14.3 特殊矩阵 178 14.4 稀疏矩阵 178 14.4.1 稀疏矩阵的存储方式 178 14.4.2 稀疏矩阵的创建 179 14.4.3 稀疏矩阵函数 180 14.5 小结 182 第15章 数据分析 183 15.1 数据分析概述和数据预处理 183 15.1.1 数据分析概述 183 15.1.2 数据导入 184 15.1.3 遗失数据的处理 185 15.2 基础统计分析 185 15.2.1 命令窗口统计分析 186 15.2.2 matlab数据统计工具 187 15.2.3 多组数据的相关分析 189 15.3 用线性回归模型拟合数据 190 15.3.1 命令窗口下的线性回归 190 15.3.2 用基本拟合工具进行回归分析 192 15.4 其他分析方法初步 195 15.4.1 有限差分 195 15.4.2 傅里叶分析初步 196 15.5 matlab统计工具箱初步 198 15.5.1 概率密度函数 198 15.5.2 概率分布函数 199 15.5.3 逆概率分布函数 200 15.5.4 随机数产生 201 15.6 小结 202 第16章 数据插值 203 16.1 一维插值 203 16.1.1 一维插值函数的使用 203 16.1.2 内插运算和外插运算 205 16.2 二维插值 208 16.3 高维插值 211 16.4 插值函数总结 211 16.5 小结 212 第17章 多项式 214 17.1 多项式基础 214 17.1.1 多项式的表示 214 17.1.2 多项式的根 215 17.1.3 多项式的创建 215 17.1.4 多项式求值 216 17.2 多项式运算 217 17.2.1 多项式乘法 217 17.2.2 多项式除法 217 17.2.3 多项式加法 218 17.2.4 多项式微分 219 17.2.5 多项式的部分分式展开 220 17.3 多项式曲线拟合 221 17.4 多项式函数总结 222 17.5 小结 223 第18章 三次样条 224 18.1 三次样条基础 224 18.2 三次样条的matlab 18.2 实现 224 18.3 小结 227 第19章 傅里叶分析 228 19.1 傅里叶变换 228 19.2 快速傅里叶变换(fft) 229 19.3 小结 233 第20章 最优化计算 234 20.1 优化工具箱简介 234 20.1.1 优化工具箱3.0的新特色 234 20.1.2 优化函数 235 20.2 无约束优化问题 237 20.2.1 一元函数无约束优化 237 20.2.2 多元函数无约束优化 238 20.3 约束优化问题 239 20.4 小结 240 第21章 微积分 241 21.1 微分 241 21.1.1 符号微分 241 21.1.2 数值微分 242 21.2 积分 242 21.2.1 符号积分 242 21.2.2 数值积分的实现方法 243 21.2.3 重积分的实现方法 245 21.3 小结 246 第22章 常微分方程 247 22.1 常微分方程符号解 247 22.2 常微分方程数值解 248 22.3 小结 251 第23章 二维图形 252 23.1 matlab图形窗口概述 252 23.2 基本绘图指令 255 23.2.1 基本绘图流程 255 23.2.2 基本绘图函数 256 23.2.3 设置函数曲线格式和标记点格式 259 23.2.4 子图绘制 261 23.2.5 迭加绘图模式 262 23.2.6 设置坐标轴和网格线 263 23.2.7 对数/半对数坐标系绘图 265 23.2.8 双纵轴绘图 266 23.2.9 绘图窗口开关控制函数 268 23.2.10 设置默认绘图格式循环顺序 269 23.2.11 复数绘图 270 23.3 图形标注 271 23.3.1 图形标注概述 271 23.3.2 图形标题 273 23.3.3 坐标轴标签 274 23.3.4 图例和颜色条 275 23.3.5 文本框标注 276 23.3.6 数据点标记 281 23.3.7 箭头和图框标注 281 23.3.8 锚定图形标注对象 283 23.4 特殊绘图 283 23.4.1 柱状图和面积图 283 23.4.2 饼图 284 23.4.3 直方图 285 23.4.4 离散数据绘图 286 23.4.5 等高线图 287 23.4.6 向量图 288 23.4.7 其他特殊绘图指令 290 23.4.8 函数绘图 292 23.5 图形窗口进阶 293 23.5.1 概述 293 23.5.2 图形面板 294 23.5.3 绘图浏览器 296 23.5.4 属性编辑器 297 23.5.5 数据查视工具 298 23.5.6 工作保存 299 23.6 小结 299 第24章 三维图形 300 24.1 创建三维图形 300 24.1.1 三维图形概述 300 24.1.2 三维曲线图 301 24.1.3 三维曲面图 302 24.1.4 特殊三维绘图 308 24.2 创建三维片块模型 314 24.2.1 创建片块模型 314 24.2.2 多个片块模型的创建和颜色设置 315 24.3 三维图形显示控制 319 24.3.1 设置坐标轴 319 24.3.2 设置视角 320 24.3.3 camera控制 321 24.3.4 其他控制工具 322 24.4 小结 322 第25章 使用颜色和光影 323 25.1 matlab中的颜色 323 25.1.1 着色技术 323 25.1.2 rgb真彩着色 324 25.1.3 颜色表 325 25.1.4 索引着色 327 25.1.5 shading模式 330 25.2 光照效果 331 25.2.1 光源对象 331 25.2.2 光照方法 332 25.3 小结 333 第26章 图像、声音和视频 334 26.1 图像 334 26.1.1 图像及其数值类型 334 26.1.2 图像处理函数 335 26.2 声音 340 26.3 视频 341 26.4 小结 342 第27章 图形的打印和导出 343 27.1 图形打印和导出概述 343 27.2 图形打印 344 27.2.1 使用菜单打印图形 344 27.2.2 图形打印命令 345 27.2.3 打印设置 346 27.3 图形导出 351 27.3.1 使用菜单导出图形 351 27.3.2 图形导出命令 351 27.3.3 导出设置 351 27.4 小结 354 第28章 句柄图形对象 355 28.1 句柄图形对象概述 355 28.2 get和set函数 356 28.3 根对象 356 28.4 图形窗口对象 357 28.5 核心图形对象 358 28.6 句柄图形对象操作 359 28.7 回调函数 360 28.8 小结 362 第29章 图形用户界面(gui) 363 29.1 gui和guide 363 29.1.1 gui程序概述 363 29.1.2 打开guide开发环境 364 29.2 使用guide创建gui界面 365 29.2.1 guide界面概述 365 29.2.2 交互组件 366 29.2.3 设计菜单 370 29.2.4 gui程序的存储 371 29.2.5 对象浏览器 372 29.2.6 gui程序的运行 373 29.3 回调函数 373 29.3.1 回调函数原型 373 29.3.2 回调函数编程 374 29.4 小结 377 第30章 matlab类和面向对象编程 378 30.1 matlab类概述 378 30.1.1 类的基本概念 378 30.1.2 类的组成 379 30.2 matlab类的设计 379 30.2.1 在matlab中设计类的基本方法 379 30.2.2 建立类目录 380 30.2.3 类的构造函数方法 380 30.2.4 类的转换方法 381 30.2.5 类的显示方法 383 30.2.6 类的subsref方法 383 30.2.7 类的重载 384 30.2.8 类方法综合使用实例 387 30.3 matlab面向对象编程 388 30.3.1 matlab面向对象编程的特点 388 30.3.2 matlab面向对象编程与其他语言对比的特点 389 30.4 小结 389 第31章 matlab编程接口 390 31.1 matlab与excel接口 390 31.1.1 excel link的使用 391 31.1.2 excel link应用举例 392 31.2 matlab与vb接口 394 31.2.1 动态链接库dll方法 394 31.2.2 利用dde方式调用 31.2.2 matlab程序 395 31.2.3 利用activex技术 395 31.3 matlab与vc++接口 396 31.3.1 使用matlab engine 396 31.3.2 mex文件 397 31.3.3 使用matcom实现matlab到c++代码转换 398 31.4 与mat文件交换数据 399 31.5 小结 400 第32章 扩展matlab和java 401 32.1 java概述 401 32.2 在matlab中使用java 402 32.2.1 java接口 402 32.2.2 matlab中调用java 403 32.3 创建和使用java对象 405 32.3.1 创建java类对象 405 32.3.2 连接java对象 406 32.3.3 调用java类对象 407 32.3.4 java实例 409 32.4 java与matlab混合编程 409 32.5 小结 410 第33章 windows应用程序集成 411 33.1 com组件 411 33.1.1 com简介 411 33.1.2 matlab com编译器 412 33.2 动态数据交换(dde) 415 33.2.1 dde基本概念 415 33.2.2 matlab中的dde 416 33.2.3 matlab作为dde的服务器端 417 33.2.4 matlab作为dde的客户端 418 33.3 notebook 420 33.3.1 notebook基础 420 33.3.2 在word中使用notebook 421 33.4 小结 422 第34章 simulink交互式仿真集成环境 423 34.1 simulink的使用 423 34.1.1 simulink启动 424 34.1.2 simulink仿真设置 425 34.1.3 simulink模块库简介 431 34.1.4 simulink功能模块的处理 443 34.2 simulink自定义功能模块 445 34.2.1 采用subsystem建立自定义功能模块 445 34.2.2 多个模块组合自定义功能模块 446 34.2.3 自定义功能模块的封装 446 34.3 s函数设计与应用 447 34.3.1 s函数设计 448 34.3.2 s函数应用 451 34.4 simulink仿真举例 452 34.5 小结 456 第35章 matlab高等数学计算实例 457 35.1 极限运算 457 35.2 求导数 458 35.2.1 一元函数求导 458 35.2.2 多元函数求导 459 35.2.3 参数方程求导 460 35.2.4 隐函数求导 460 35.2.5 求梯度与方向导数 460 35.3 求积分 461 35.3.1 定积分 461 35.3.2 广义积分 462 35.3.3 重积分 462 35.3.4 不定积分 462 35.4 级数 463 35.4.1 级数展开 463 35.4.2 级数求和 463 35.5 求函数的零点和极值点 463 35.5.1 求函数的零点 463 35.5.2 求函数的极值点 464 35.6 代数方程组求解 465 35.6.1 线性方程组求解 465 35.6.2 非线性方程组求解 471 35.7 常微分方程求解 472 35.7.1 常微分方程的符号解 472 35.7.2 常微分方程组数值解 472 35.8 小结 474 第36章 matlab图形绘制实例 475 36.1 二维绘图 475 36.1.1 函数绘图 475 36.1.2 离散数据绘图 477 36.1.3 特殊坐标轴绘图 479 36.2 三维绘图 480 36.2.1 二元函数绘图 480 36.2.2 三维曲线绘图 481 36.2.3 三维曲面绘图 482 36.3 特殊分析用图 482 36.3.1 柱状图 482 36.3.2 直方图 483 36.3.3 饼图 484 36.3.4 散点图 484 36.3.5 等高线图 485 36.4 小结 486 37.1 matlab与vc++混合编程概述 487 第37章 matlab扩展编程实例 487 37.1.1 混合编程的背景 487 37.1.2 混合编程的方式 488 37.2 使用matlab引擎 488 37.2.1 matlab引擎 488 37.2.2 编程实例 492 37.3 使用mcc编译器 495 37.3.1 mcc编译器 495 37.3.2 matlab的设置及创建动态链接库 496 37.3.3 编程实例 498 37.4 使用com 501 37.4.1 com简介 501 37.4.2 com的设置与创建 501 37.4.3 vc++中调用com 505 37.5 小结 507 参考文献 508

[精通MATLAB].葛哲学.清晰版 [精通MATLAB].葛哲学.清晰版

[嵌入式Linux应用开发完全手册].有目录

高等应用数学问题的matlab求解ocr

目录： 第一部分 客户层 1 Item 1：当Runtime.exec()运行出错时 4 Item 2：NIO的效率和陷阱 16 Item 3：我宁愿不使用属性 31 Item 4：当信息隐藏得太多时 35 Item 5：避免java.util.logging中的粒度陷阱 41 Item 6：当标准API的实现发生冲突时 49 Item 7：断言绝非多余 55 Item 8：查找DOM的错误方法 61 Item 9：保存一个DOM的困境 68 Item 10：鼠标按钮的可移植性 74 Item 11：Apache Ant和生命周期管理 81 Item 12：JUnit：单元测试使事情变得简单 92 Item 13：执行的失败 100 Item 14：你收集了什么 104 Item 15：避免Singleton陷阱 108 Item 16：当setSize()不能如愿时 113 Item 17：当POST到一个URL无法如愿时 117 Item 18：有效的字符串标记化 130 Item 19：JLayered Pane陷阱 135 Item 20：File.renameTo为什么失败 140 Item 21：使用迭代替代枚举 146 Item 22：J2ME的效率和陷阱 150 第二部分 Web层 185 Item 23：珍贵的缓存 186 Item 24：JSP设计错误 193 Item 25: 当Servlet HttpSession发生冲突时 205 Item 26：当Applet走向失败时 211 Item 27：事务性LDAP-不要进行提交 217 Item 28：与过滤器有关的问题 226 Item 29：关于JSP复用和内容发布的一些指导 236 Item 30：使用正则表达式进行表单验证 242 Item 31：Servlet中的实例变量 249 Item 32：使用Servlet创建数据库连接的设计缺陷 258 Item 33：试图在Servlet中使用两种输出机制 270 Item 34：神秘的文件协议 276 Item 35：从Servlet读取文件 280 Item 36：太多的提交 290 第三部分 企业层 303 Item 37：J2EE体系结构的考虑 305 Item 38：消除网络瓶颈陷阱的设计策略 311 Item 39：我将使用本地接口 317 Item 40：图像的困扰 323 Item 41：多重并发结果集的问题 328 Item 42：为EJB生成主键 334 Item 43：有状态的无状态会话Bean 339 Item 44：未准备的PreparedStatement 346 Item 45：探索资源池 351 Item 46：JDO 和数据持久化 357 Item 47：WSDL位于何处？在UDDI中使用JAXR的陷阱 370 Item 48：JAX-RPC应用程序客户存在的效率陷阱 388 Item 49：让你的Bean远离我的文件系统 398 Item 50：当事务出错时如何保持有状态会话EJB的一致性状态 402 索引 411

OpenGL编程与实例 第一篇 基础知识篇 第1章 Viual C++ 6.0开发环境 1.1 开反平台 1.1.1 工具条 1.1.2 项目工程 1.1.3 工程窗口 1.2 项目操作 l.2.1 项目配置 l.2.2 项目类型 1.2.3 转换旧的项目 1.2.4 同时进行多个项目 1.3 VisualC++ 6.0的其他工具 l.3.1 Classwzard(类模板) l.3.2 组件廊 1.3.3 集成调试器 1.3.4 命令行工具 1.4 小结 第 2章 MFC框架、文档和视 2.1 应用程序向导及MFC程序框架 2.1.1 Appwzard的作用 2.1.2 MFC应用程序框架 2.2 用Appwzard创建 MFC应用程序 2.3 Appwizard创建的类 2.3.1 CDocument、 CVew及Frame类 2.3.2 CWnApp类 2.3.3 CObject类 2.4 MFC消息和命令 2.4.1 消息的种类 2.4.2 MFC中的标准命令消息处理 2.4.3 用Classwzard进行消息处理 2.4.4 创建自定义的消息映射 2.4.5 消息发送 2.5 框架、文档和视 2.5.1 几个基本概念 2.5.2 又档 2.5.3 视类 2.5.4 文档模板 2.6 小结 第3章 计算机图形学基础知识 3.1 图形变换 3.1.1 齐次坐标: 3.1.2 用户域和窗口区 3.1.3 图形的几何变换 3.1.4 三维形体的投影变换 3.2 真实感图形 3.2.1 隐藏面的消除 3.2.2 明暗效应 3.2.3 颜色模型 3.2.4 纹理 3.3 小结 第4章 初识 OpenGL 4.1 OpenGL是什么 4.2 为什么要选择 OpenGL 4.3 OpenGL是如何工作的 4.3.1 OpenGL运行平台 4.3.2 OpenGL基本工作流程 4.3.3 Windows系统下的 OpenGL函数库 4.3.4 OpenGL++与 OpenGLOPtlnuzer 4.4 小结 第二篇 OpenGL入门篇 第5章 用MFC编写OpenGL程序 5.1 简介 5.2 MFC开发 OpenGL的准备 5.2.1 图形操作描述表 5.2.2 像素格式(Pixel Format) 5.3 Cube——OpenGL例程 5.3.1 进入 Visual C++ 5.3.2 用之前的准备 5.3.3 消息函数的填充 5.3.4 需要注意的几个问题 5.4 小结 第6章 OpenGL基础 6.1 OpenGL的基本语法 6.2 OpenGL相关函数库 6.3 OpenGL中的几何建模基础 6.3.1 点的绘制 6.3.2 线的绘制 6.3.3 多边形的绘制 6.4 图形显示 6.4.1 窗口的刷新 6.4.2 颜色的指定 6.4.3 绘图的强制完成 6.4.4 消隐 6.5 小结 第7章 图形变换 7.1 OpenGL图形变换概述 7.2 投影变换 7.2.1 正交投影变换 7.2.2 透视投影变换 7.3 视区变换 7.4 裁减变换 7.5 几何变换 7.6 矩阵堆栈 7.7 小结 第8章 颜色与光照 8.1 OpenGL中的颜色模式 8.1.1 RGBA模式 8.1.2 颜色索引表模式 8.1.3 阴影模型 8.2 OpenGL中的光照 8.2.1 OpenGL光源 8.2.2 OpenGL的光照模型 8.2.3 OpenGL中的材质 8.3 小结 第9章 混合、反走样和雾 9.1 混合 9.1.1 混合运算与函数 9.1.2 混合范例 9.2 反走样 9.2.1 反走样运算与函数 9.2.2 反走样范例 9.3 雾 9.3.1 雾的运算与函数 9.3.2 雾的使用范例 9.4 小结 第10章 显示列表、位图和图像 10.1 显示列表 10.1.1 显示列表的设计与相关函数. 10.1.2 显示列表应用范例 10.2 位图 10.2.1 位图的操作及函数 10.2.2 位图应用范例 10.3 图像 10.3.1 图像的操作及函数 10.3.2 图像应用范例 10.4 小结 第11章 OpenGL纹理映射 11.1 OpenGL纹理概述 11.2 OpenGL中纹理定义 11.3 纹理控制 11.4 纹理的调节和混合 11.5 计算纹理坐标 11.6 纹理矩阵难栈 11.7 小结 第12章 复杂图形的绘制 12.1 基本图元的扩展 12.1.1 点和线的扩展 12.1.2 多边形的扩展 12.2 法向计算 12.2.1 法向基本计算方法 12.2.2 法向定义 12.3 复杂图形的绘制方法 12.3.1 求值程序概述 12.3.2 求值程序 12.3.3 一维求值程序 12.3.4 二维求值程序 12.4 GLU的 NURBS接口程序 12.4.1 简单的NURBS范例 12.4.2 修剪 12.5 小结 第三篇 WindowS编程实用与提高篇 第13章 OpenGL与其他建模工具的接口 13.1 AutoCAD与 3DS MAX简介 13.2 DXF文件格式分析 13.2.1 DXF文件的基本结构 13.2.2 实体段分析 13.3 DXF接口程序的编写 13.4 OpenGL的DXF扩展库函数的制作 13.5 3DS格式的数据文件的调用 13.6 小结 第14章 OpenGL视类及其应用 14.1 OpenGL的回顾 14.1.1 使用 OpenGL 14.1.2 OpenGL入门 14.1.3 启动 OpenGL 14.2 融合OpenGL和MFC 14.2.1 建立新的工程 14.2.2 定制“窗口” 14.2.3 调色板的管理 14.2.4 其他相关的成员函数 14.2.5 三维渲染 14.3 使用CGLEnabledView类 14.4 小结 第15章 帧缓存和动画 15.1 缓存及其使用 15.1.1 帧缓存的组成 15.1.2 各种缓存概述 15.1.3 清空缓存 15.1.4 为写操作选择颜色缓存 15.1.5 缓存屏蔽 15.2 图元的测试与操作 15.2.1 剪取测试 15.2.2 alpha测试 15.2.3 模板测试 15.2.4 深度测试 15.2.5 混合、抖动及逻辑操作 15.3 累积缓存 15.3.1 场景锯齿现象的消除 15.3、2 运动模糊度 15.3.3 景深 15.3.4 柔和阴影 15.3.5 抖动 15.4 动画的实现 15.5 小结 第16章 打印渲染后的OpenGL场景 16.1 问题的提出 16.2 实现步骤 16.2.1 动画的实现 16.2.2 打印功能的实现 16.3 技术内幕 16.3.1 BMP图像文件格式简介 16.3.2 DIB、颜色以及调色板 16.3.3 BMP文件格式介绍 16.4 小结 附录1 OpenGL的常数及其相关函数 附录2 OpenGL常用函数简介

如何下载 Intel Integrated Performance Primitives –intel IPP

跟我一起写Makefile 概述 —— 什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。 在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。 关于程序的编译和链接 —————————— 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即 Object File，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。 编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。 链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（O文件或是OBJ文件）来链接我们的应用程序。链接器并不管函数所在的源文件，只管函数的中间目标文件（Object File），在大多数时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给中间目标文件打个包，在Windows下这种包叫“库文件”（Library File)，也就是 .lib 文件，在UNIX下，是Archive File，也就是 .a 文件。 总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明，编译器会给出一个警告，但可以生成Object File。而在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error），在VC下，这种错误一般是：Link 2001错误，意思说是说，链接器未能找到函数的实现。你需要指定函数的Object File. 好，言归正传，GNU的make有许多的内容，闲言少叙，还是让我们开始吧。 Makefile 介绍 ——————— make命令执行时，需要一个 Makefile 文件，以告诉make命令需要怎么样的去编译和链接程序。 首先，我们用一个示例来说明Makefile的书写规则。以便给大家一个感兴认识。这个示例来源于GNU的make使用手册，在这个示例中，我们的工程有8个C文件，和3个头文件，我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。我们的规则是： 1）如果这个工程没有编译过，那么我们的所有C文件都要编译并被链接。 2）如果这个工程的某几个C文件被修改，那么我们只编译被修改的C文件，并链接目标程序。 3）如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的C文件，并链接目标程序。 只要我们的Makefile写得够好，所有的这一切，我们只用一个make命令就可以完成，make命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自己编译所需要的文件和链接目标程序。 一、Makefile的规则 在讲述这个Makefile之前，还是让我们先来粗略地看一看Makefile的规则。 target ... : prerequisites ... command ... ... target也就是一个目标文件，可以是Object File，也可以是执行文件。还可以是一个标签（Label），对于标签这种特性，在后续的“伪目标”章节中会有叙述。 prerequisites就是，要生成那个target所需要的文件或是目标。 command也就是make需要执行的命令。（任意的Shell命令） 这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在command中。说白一点就是说，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。这就是Makefile的规则。也就是Makefile中最核心的内容。 说到底，Makefile的东西就是这样一点，好像我的这篇文档也该结束了。呵呵。还不尽然，这是Makefile的主线和核心，但要写好一个Makefile还不够，我会以后面一点一点地结合我的工作经验给你慢慢到来。内容还多着呢。：） 二、一个示例 正如前面所说的，如果一个工程有3个头文件，和8个C文件，我们为了完成前面所述的那三个规则，我们的Makefile应该是下面的这个样子的。 edit : main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o cc -o edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o main.o : main.c defs.h cc -c main.c kbd.o : kbd.c defs.h command.h cc -c kbd.c command.o : command.c defs.h command.h cc -c command.c display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.h buffer.h cc -c insert.c search.o : search.c defs.h buffer.h cc -c search.c files.o : files.c defs.h buffer.h command.h cc -c files.c utils.o : utils.c defs.h cc -c utils.c clean : rm edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o 反斜杠（\）是换行符的意思。这样比较便于Makefile的易读。我们可以把这个内容保存在文件为“Makefile”或“makefile”的文件中，然后在该目录下直接输入命令“make”就可以生成执行文件edit。如果要删除执行文件和所有的中间目标文件，那么，只要简单地执行一下“make clean”就可以了。 在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（*.o），依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h文件。每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。 在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个Tab键作为开头。记住，make并不管命令是怎么工作的，他只管执行所定义的命令。make会比较targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期要比targets文件的日期要新，或者target不存在的话，那么，make就会执行后续定义的命令。 这里要说明一点的是，clean不是一个文件，它只不过是一个动作名字，有点像C语言中的lable一样，其冒号后什么也没有，那么，make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。要执行其后的命令，就要在make命令后明显得指出这个lable的名字。这样的方法非常有用，我们可以在一个makefile中定义不用的编译或是和编译无关的命令，比如程序的打包，程序的备份，等等。 xlongjiu 回复于：2004-09-16 11:08:46 狂顶！ torrent 回复于：2004-09-16 11:13:36 写的还算不错 gunguymadman 回复于：2004-09-16 12:18:05 三、make是如何工作的 在默认的方式下，也就是我们只输入make命令。那么， 1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。 2、如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到“edit”这个文件，并把这个文件作为最终的目标文件。 3、如果edit文件不存在，或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个文件新，那么，他就会执行后面所定义的命令来生成edit这个文件。 4、如果edit所依赖的.o文件也存在，那么make会在当前文件中找目标为.o文件的依赖性，如果找到则再根据那一个规则生成.o文件。（这有点像一个堆栈的过程） 5、当然，你的C文件和H文件是存在的啦，于是make会生成 .o 文件，然后再用 .o 文件生命make的终极任务，也就是执行文件edit了。 这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。make只管文件的依赖性，即，如果在我找了依赖关系之后，冒号后面的文件还是不在，那么对不起，我就不工作啦。 通过上述分析，我们知道，像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令将不会被自动执行，不过，我们可以显示要make执行。即命令——“make clean”，以此来清除所有的目标文件，以便重编译。 于是在我们编程中，如果这个工程已被编译过了，当我们修改了其中一个源文件，比如file.c，那么根据我们的依赖性，我们的目标file.o会被重编译（也就是在这个依性关系后面所定义的命令），于是file.o的文件也是最新的啦，于是file.o的文件修改时间要比edit要新，所以edit也会被重新链接了（详见edit目标文件后定义的命令）。 而如果我们改变了“command.h”，那么，kdb.o、command.o和files.o都会被重编译，并且，edit会被重链接。 四、makefile中使用变量 在上面的例子中，先让我们看看edit的规则： edit : main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o cc -o edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o 我们可以看到[.o]文件的字符串被重复了两次，如果我们的工程需要加入一个新的[.o]文件，那么我们需要在两个地方加（应该是三个地方，还有一个地方在clean中）。当然，我们的makefile并不复杂，所以在两个地方加也不累，但如果makefile变得复杂，那么我们就有可能会忘掉一个需要加入的地方，而导致编译失败。所以，为了makefile的易维护，在makefile中我们可以使用变量。makefile的变量也就是一个字符串，理解成C语言中的宏可能会更好。 比如，我们声明一个变量，叫objects, OBJECTS, objs, OBJS, obj, 或是 OBJ，反正不管什么啦，只要能够表示obj文件就行了。我们在makefile一开始就这样定义： objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o 于是，我们就可以很方便地在我们的makefile中以“$(objects)”的方式来使用这个变量了，于是我们的改良版makefile就变成下面这个样子： objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o edit : $(objects) cc -o edit $(objects) main.o : main.c defs.h cc -c main.c kbd.o : kbd.c defs.h command.h cc -c kbd.c command.o : command.c defs.h command.h cc -c command.c display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.h buffer.h cc -c insert.c search.o : search.c defs.h buffer.h cc -c search.c files.o : files.c defs.h buffer.h command.h cc -c files.c utils.o : utils.c defs.h cc -c utils.c clean : rm edit $(objects) 于是如果有新的 .o 文件加入，我们只需简单地修改一下 objects 变量就可以了。 关于变量更多的话题，我会在后续给你一一道来。 五、让make自动推导 GNU的make很强大，它可以自动推导文件以及文件依赖关系后面的命令，于是我们就没必要去在每一个[.o]文件后都写上类似的命令，因为，我们的make会自动识别，并自己推导命令。 只要make看到一个[.o]文件，它就会自动的把[.c]文件加在依赖关系中，如果make找到一个whatever.o，那么whatever.c，就会是whatever.o的依赖文件。并且 cc -c whatever.c 也会被推导出来，于是，我们的makefile再也不用写得这么复杂。我们的是新的makefile又出炉了。 objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o edit : $(objects) cc -o edit $(objects) main.o : defs.h kbd.o : defs.h command.h command.o : defs.h command.h display.o : defs.h buffer.h insert.o : defs.h buffer.h search.o : defs.h buffer.h files.o : defs.h buffer.h command.h utils.o : defs.h .PHONY : clean clean : rm edit $(objects) 这种方法，也就是make的“隐晦规则”。上面文件内容中，“.PHONY”表示，clean是个伪目标文件。 关于更为详细的“隐晦规则”和“伪目标文件”，我会在后续给你一一道来。 六、另类风格的makefile 即然我们的make可以自动推导命令，那么我看到那堆[.o]和[.h]的依赖就有点不爽，那么多的重复的[.h]，能不能把其收拢起来，好吧，没有问题，这个对于make来说很容易，谁叫它提供了自动推导命令和文件的功能呢？来看看最新风格的makefile吧。 objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o edit : $(objects) cc -o edit $(objects) $(objects) : defs.h kbd.o command.o files.o : command.h display.o insert.o search.o files.o : buffer.h .PHONY : clean clean : rm edit $(objects) 这种风格，让我们的makefile变得很简单，但我们的文件依赖关系就显得有点凌乱了。鱼和熊掌不可兼得。还看你的喜好了。我是不喜欢这种风格的，一是文件的依赖关系看不清楚，二是如果文件一多，要加入几个新的.o文件，那就理不清楚了。 七、清空目标文件的规则 每个Makefile中都应该写一个清空目标文件（.o和执行文件）的规则，这不仅便于重编译，也很利于保持文件的清洁。这是一个“修养”（呵呵，还记得我的《编程修养》吗）。一般的风格都是： clean: rm edit $(objects) 更为稳健的做法是： .PHONY : clean clean : -rm edit $(objects) 前面说过，.PHONY意思表示clean是一个“伪目标”，。而在rm命令前面加了一个小减号的意思就是，也许某些文件出现问题，但不要管，继续做后面的事。当然，clean的规则不要放在文件的开头，不然，这就会变成make的默认目标，相信谁也不愿意这样。不成文的规矩是——“clean从来都是放在文件的最后”。 上面就是一个makefile的概貌，也是makefile的基础，下面还有很多makefile的相关细节，准备好了吗？准备好了就来。 <-上 gunguymadman 回复于：2004-09-16 12:18:58 一、Makefile里有什么？ Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。 1、显式规则。显式规则说明了，如何生成一个或多的的目标文件。这是由Makefile的书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。 2、隐晦规则。由于我们的make有自动推导的功能，所以隐晦的规则可以让我们比较粗糙地简略地书写Makefile，这是由make所支持的。 3、变量的定义。在Makefile中我们要定义一系列的变量，变量一般都是字符串，这个有点你C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。 4、文件指示。其包括了三个部分，一个是在一个Makefile中引用另一个Makefile，就像C语言中的include一样；另一个是指根据某些情况指定Makefile中的有效部分，就像C语言中的预编译#if一样；还有就是定义一个多行的命令。有关这一部分的内容，我会在后续的部分中讲述。 5、注释。Makefile中只有行注释，和UNIX的Shell脚本一样，其注释是用“#”字符，这个就像C/C++中的“//”一样。如果你要在你的Makefile中使用“#”字符，可以用反斜框进行转义，如：“\#”。 最后，还值得一提的是，在Makefile中的命令，必须要以[Tab]键开始。 二、Makefile的文件名 默认的情况下，make命令会在当前目录下按顺序找寻文件名为“GNUmakefile”、“makefile”、“Makefile”的文件，找到了解释这个文件。在这三个文件名中，最好使用“Makefile”这个文件名，因为，这个文件名第一个字符为大写，这样有一种显目的感觉。最好不要用“GNUmakefile”，这个文件是GNU的make识别的。有另外一些make只对全小写的“makefile”文件名敏感，但是基本上来说，大多数的make都支持“makefile”和“Makefile”这两种默认文件名。 当然，你可以使用别的文件名来书写Makefile，比如：“Make.Linux”，“Make.Solaris”，“Make.AIX”等，如果要指定特定的Makefile，你可以使用make的“-f”和“--file”参数，如：make -f Make.Linux或make --file Make.AIX。 三、引用其它的Makefile 在Makefile使用include关键字可以把别的Makefile包含进来，这很像C语言的#include，被包含的文件会原模原样的放在当前文件的包含位置。include的语法是： include <filename>; filename可以是当前操作系统Shell的文件模式（可以保含路径和通配符） 在include前面可以有一些空字符，但是绝不能是[Tab]键开始。include和<filename>;可以用一个或多个空格隔开。举个例子，你有这样几个Makefile：a.mk、b.mk、c.mk，还有一个文件叫foo.make，以及一个变量$(bar)，其包含了e.mk和f.mk，那么，下面的语句： include foo.make *.mk $(bar) 等价于： include foo.make a.mk b.mk c.mk e.mk f.mk make命令开始时，会把找寻include所指出的其它Makefile，并把其内容安置在当前的位置。就好像C/C++的#include指令一样。如果文件都没有指定绝对路径或是相对路径的话，make会在当前目录下首先寻找，如果当前目录下没有找到，那么，make还会在下面的几个目录下找： 1、如果make执行时，有“-I”或“--include-dir”参数，那么make就会在这个参数所指定的目录下去寻找。 2、如果目录<prefix>;/include（一般是：/usr/local/bin或/usr/include）存在的话，make也会去找。 如果有文件没有找到的话，make会生成一条警告信息，但不会马上出现致命错误。它会继续载入其它的文件，一旦完成makefile的读取，make会再重试这些没有找到，或是不能读取的文件，如果还是不行，make才会出现一条致命信息。如果你想让make不理那些无法读取的文件，而继续执行，你可以在include前加一个减号“-”。如： -include <filename>; 其表示，无论include过程中出现什么错误，都不要报错继续执行。和其它版本make兼容的相关命令是sinclude，其作用和这一个是一样的。 四、环境变量 MAKEFILES 如果你的当前环境中定义了环境变量MAKEFILES，那么，make会把这个变量中的值做一个类似于include的动作。这个变量中的值是其它的Makefile，用空格分隔。只是，它和include不同的是，从这个环境变中引入的Makefile的“目标”不会起作用，如果环境变量中定义的文件发现错误，make也会不理。 但是在这里我还是建议不要使用这个环境变量，因为只要这个变量一被定义，那么当你使用make时，所有的Makefile都会受到它的影响，这绝不是你想看到的。在这里提这个事，只是为了告诉大家，也许有时候你的Makefile出现了怪事，那么你可以看看当前环境中有没有定义这个变量。 五、make的工作方式 GNU的make工作时的执行步骤入下：（想来其它的make也是类似） 1、读入所有的Makefile。 2、读入被include的其它Makefile。 3、初始化文件中的变量。 4、推导隐晦规则，并分析所有规则。 5、为所有的目标文件创建依赖关系链。 6、根据依赖关系，决定哪些目标要重新生成。 7、执行生成命令。 1-5步为第一个阶段，6-7为第二个阶段。第一个阶段中，如果定义的变量被使用了，那么，make会把其展开在使用的位置。但make并不会完全马上展开，make使用的是拖延战术，如果变量出现在依赖关系的规则中，那么仅当这条依赖被决定要使用了，变量才会在其内部展开。 当然，这个工作方式你不一定要清楚，但是知道这个方式你也会对make更为熟悉。有了这个基础，后续部分也就容易看懂了。 gunguymadman 回复于：2004-09-16 12:19:56 书写规则 ———— 规则包含两个部分，一个是依赖关系，一个是生成目标的方法。 在Makefile中，规则的顺序是很重要的，因为，Makefile中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让make知道你的最终目标是什么。一般来说，定义在Makefile中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个，那么，第一个目标会成为最终的目标。make所完成的也就是这个目标。 好了，还是让我们来看一看如何书写规则。 一、规则举例 foo.o : foo.c defs.h # foo模块 cc -c -g foo.c 看到这个例子，各位应该不是很陌生了，前面也已说过，foo.o是我们的目标，foo.c和defs.h是目标所依赖的源文件，而只有一个命令“cc -c -g foo.c”（以Tab键开头）。这个规则告诉我们两件事： 1、文件的依赖关系，foo.o依赖于foo.c和defs.h的文件，如果foo.c和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存在，那么依赖关系发生。 2、如果生成（或更新）foo.o文件。也就是那个cc命令，其说明了，如何生成foo.o这个文件。（当然foo.c文件include了defs.h文件） 二、规则的语法 targets : prerequisites command ... 或是这样： targets : prerequisites ; command command ... targets是文件名，以空格分开，可以使用通配符。一般来说，我们的目标基本上是一个文件，但也有可能是多个文件。 command是命令行，如果其不与“target:prerequisites”在一行，那么，必须以[Tab键]开头，如果和prerequisites在一行，那么可以用分号做为分隔。（见上） prerequisites也就是目标所依赖的文件（或依赖目标）。如果其中的某个文件要比目标文件要新，那么，目标就被认为是“过时的”，被认为是需要重生成的。这个在前面已经讲过了。 如果命令太长，你可以使用反斜框（‘\’）作为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事，文件的依赖关系和如何成成目标文件。 一般来说，make会以UNIX的标准Shell，也就是/bin/sh来执行命令。 三、在规则中使用通配符 如果我们想定义一系列比较类似的文件，我们很自然地就想起使用通配符。make支持三各通配符：“*”，“?”和“[...]”。这是和Unix的B-Shell是相同的。 波浪号（“~”）字符在文件名中也有比较特殊的用途。如果是“~/test”，这就表示当前用户的$HOME目录下的test目录。而“~hchen/test”则表示用户hchen的宿主目录下的test目录。（这些都是Unix下的小知识了，make也支持）而在Windows或是MS-DOS下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。 通配符代替了你一系列的文件，如“*.c”表示所以后缀为c的文件。一个需要我们注意的是，如果我们的文件名中有通配符，如：“*”，那么可以用转义字符“\”，如“\*”来表示真实的“*”字符，而不是任意长度的字符串。 好吧，还是先来看几个例子吧： clean: rm -f *.o 上面这个例子我不不多说了，这是操作系统Shell所支持的通配符。这是在命令中的通配符。 print: *.c lpr -p $? touch print 上面这个例子说明了通配符也可以在我们的规则中，目标print依赖于所有的[.c]文件。其中的“$?”是一个自动化变量，我会在后面给你讲述。 objects = *.o 上面这个例子，表示了，通符同样可以用在变量中。并不是说[*.o]会展开，不！objects的值就是“*.o”。Makefile中的变量其实就是C/C++中的宏。如果你要让通配符在变量中展开，也就是让objects的值是所有[.o]的文件名的集合，那么，你可以这样： objects := $(wildcard *.o) 这种用法由关键字“wildcard”指出，关于Makefile的关键字，我们将在后面讨论。 四、文件搜寻 在一些大的工程中，有大量的源文件，我们通常的做法是把这许多的源文件分类，并存放在不同的目录中。所以，当make需要去找寻文件的依赖关系时，你可以在文件前加上路径，但最好的方法是把一个路径告诉make，让make在自动去找。 Makefile文件中的特殊变量“VPATH”就是完成这个功能的，如果没有指明这个变量，make只会在当前的目录中去找寻依赖文件和目标文件。如果定义了这个变量，那么，make就会在当当前目录找不到的情况下，到所指定的目录中去找寻文件了。 VPATH = src:../headers 上面的的定义指定两个目录，“src”和“../headers”，make会按照这个顺序进行搜索。目录由“冒号”分隔。（当然，当前目录永远是最高优先搜索的地方） 另一个设置文件搜索路径的方法是使用make的“vpath”关键字（注意，它是全小写的），这不是变量，这是一个make的关键字，这和上面提到的那个VPATH变量很类似，但是它更为灵活。它可以指定不同的文件在不同的搜索目录中。这是一个很灵活的功能。它的使用方法有三种： 1、vpath <pattern>; <directories>; 为符合模式<pattern>;的文件指定搜索目录<directories>;。 2、vpath <pattern>; 清除符合模式<pattern>;的文件的搜索目录。 3、vpath 清除所有已被设置好了的文件搜索目录。 vapth使用方法中的<pattern>;需要包含“%”字符。“%”的意思是匹配零或若干字符，例如，“%.h”表示所有以“.h”结尾的文件。<pattern>;指定了要搜索的文件集，而<directories>;则指定了<pattern>;的文件集的搜索的目录。例如： vpath %.h ../headers 该语句表示，要求make在“../headers”目录下搜索所有以“.h”结尾的文件。（如果某文件在当前目录没有找到的话） 我们可以连续地使用vpath语句，以指定不同搜索策略。如果连续的vpath语句中出现了相同的<pattern>;，或是被重复了的<pattern>;，那么，make会按照vpath语句的先后顺序来执行搜索。如： vpath %.c foo vpath % blish vpath %.c bar 其表示“.c”结尾的文件，先在“foo”目录，然后是“blish”，最后是“bar”目录。 vpath %.c foo:bar vpath % blish 而上面的语句则表示“.c”结尾的文件，先在“foo”目录，然后是“bar”目录，最后才是“blish”目录。 五、伪目标 最早先的一个例子中，我们提到过一个“clean”的目标，这是一个“伪目标”， clean: rm *.o temp 正像我们前面例子中的“clean”一样，即然我们生成了许多文件编译文件，我们也应该提供一个清除它们的“目标”以备完整地重编译而用。 （以“make clean”来使用该目标） 因为，我们并不生成“clean”这个文件。“伪目标”并不是一个文件，只是一个标签，由于“伪目标”不是文件，所以make无法生成它的依赖关系和决定它是否要执行。我们只有通过显示地指明这个“目标”才能让其生效。当然，“伪目标”的取名不能和文件名重名，不然其就失去了“伪目标”的意义了。 当然，为了避免和文件重名的这种情况，我们可以使用一个特殊的标记“.PHONY”来显示地指明一个目标是“伪目标”，向make说明，不管是否有这个文件，这个目标就是“伪目标”。 .PHONY : clean 只要有这个声明，不管是否有“clean”文件，要运行“clean”这个目标，只有“make clean”这样。于是整个过程可以这样写： .PHONY: clean clean: rm *.o temp 伪目标一般没有依赖的文件。但是，我们也可以为伪目标指定所依赖的文件。伪目标同样可以作为“默认目标”，只要将其放在第一个。一个示例就是，如果你的Makefile需要一口气生成若干个可执行文件，但你只想简单地敲一个make完事，并且，所有的目标文件都写在一个Makefile中，那么你可以使用“伪目标”这个特性： all : prog1 prog2 prog3 .PHONY : all prog1 : prog1.o utils.o cc -o prog1 prog1.o utils.o prog2 : prog2.o cc -o prog2 prog2.o prog3 : prog3.o sort.o utils.o cc -o prog3 prog3.o sort.o utils.o 我们知道，Makefile中的第一个目标会被作为其默认目标。我们声明了一个“all”的伪目标，其依赖于其它三个目标。由于伪目标的特性是，总是被执行的，所以其依赖的那三个目标就总是不如“all”这个目标新。所以，其它三个目标的规则总是会被决议。也就达到了我们一口气生成多个目标的目的。“.PHONY : all”声明了“all”这个目标为“伪目标”。 随便提一句，从上面的例子我们可以看出，目标也可以成为依赖。所以，伪目标同样也可成为依赖。看下面的例子： .PHONY: cleanall cleanobj cleandiff cleanall : cleanobj cleandiff rm program cleanobj : rm *.o cleandiff : rm *.diff “make clean”将清除所有要被清除的文件。“cleanobj”和“cleandiff”这两个伪目标有点像“子程序”的意思。我们可以输入“make cleanall”和“make cleanobj”和“make cleandiff”命令来达到清除不同种类文件的目的。 gunguymadman 回复于：2004-09-16 12:20:43 六、多目标 Makefile的规则中的目标可以不止一个，其支持多目标，有可能我们的多个目标同时依赖于一个文件，并且其生成的命令大体类似。于是我们就能把其合并起来。当然，多个目标的生成规则的执行命令是同一个，这可能会可我们带来麻烦，不过好在我们的可以使用一个自动化变量“$@”（关于自动化变量，将在后面讲述），这个变量表示着目前规则中所有的目标的集合，这样说可能很抽象，还是看一个例子吧。 bigoutput littleoutput : text.g generate text.g -$(subst output,,$@) >; $@ 上述规则等价于： bigoutput : text.g generate text.g -big >; bigoutput littleoutput : text.g generate text.g -little >; littleoutput 其中，-$(subst output,,$@)中的“$”表示执行一个Makefile的函数，函数名为subst，后面的为参数。关于函数，将在后面讲述。这里的这个函数是截取字符串的意思，“$@”表示目标的集合，就像一个数组，“$@”依次取出目标，并执于命令。 七、静态模式 静态模式可以更加容易地定义多目标的规则，可以让我们的规则变得更加的有弹性和灵活。我们还是先来看一下语法： <targets ...>;: <target-pattern>;: <prereq-patterns ...>; <commands>; ... targets定义了一系列的目标文件，可以有通配符。是目标的一个集合。 target-parrtern是指明了targets的模式，也就是的目标集模式。 prereq-parrterns是目标的依赖模式，它对target-parrtern形成的模式再进行一次依赖目标的定义。 这样描述这三个东西，可能还是没有说清楚，还是举个例子来说明一下吧。如果我们的<target-parrtern>;定义成“%.o”，意思是我们的<target>;集合中都是以“.o”结尾的，而如果我们的<prereq-parrterns>;定义成“%.c”，意思是对<target-parrtern>;所形成的目标集进行二次定义，其计算方法是，取<target-parrtern>;模式中的“%”（也就是去掉了[.o]这个结尾），并为其加上[.c]这个结尾，形成的新集合。 所以，我们的“目标模式”或是“依赖模式”中都应该有“%”这个字符，如果你的文件名中有“%”那么你可以使用反斜杠“\”进行转义，来标明真实的“%”字符。 看一个例子： objects = foo.o bar.o all: $(objects) $(objects): %.o: %.c $(CC) -c $(CFLAGS) $< -o $@ 上面的例子中，指明了我们的目标从$object中获取，“%.o”表明要所有以“.o”结尾的目标，也就是“foo.o bar.o”，也就是变量$object集合的模式，而依赖模式“%.c”则取模式“%.o”的“%”，也就是“foo bar”，并为其加下“.c”的后缀，于是，我们的依赖目标就是“foo.c bar.c”。而命令中的“$<”和“$@”则是自动化变量，“$<”表示所有的依赖目标集（也就是“foo.c bar.c”），“$@”表示目标集（也就是“foo.o bar.o”）。于是，上面的规则展开后等价于下面的规则： foo.o : foo.c $(CC) -c $(CFLAGS) foo.c -o foo.o bar.o : bar.c $(CC) -c $(CFLAGS) bar.c -o bar.o 试想，如果我们的“%.o”有几百个，那种我们只要用这种很简单的“静态模式规则”就可以写完一堆规则，实在是太有效率了。“静态模式规则”的用法很灵活，如果用得好，那会一个很强大的功能。再看一个例子： files = foo.elc bar.o lose.o $(filter %.o,$(files)): %.o: %.c $(CC) -c $(CFLAGS) $< -o $@ $(filter %.elc,$(files)): %.elc: %.el emacs -f batch-byte-compile $< $(filter %.o,$(files))表示调用Makefile的filter函数，过滤“$filter”集，只要其中模式为“%.o”的内容。其的它内容，我就不用多说了吧。这个例字展示了Makefile中更大的弹性。 八、自动生成依赖性 在Makefile中，我们的依赖关系可能会需要包含一系列的头文件，比如，如果我们的main.c中有一句“#include "defs.h"”，那么我们的依赖关系应该是： main.o : main.c defs.h 但是，如果是一个比较大型的工程，你必需清楚哪些C文件包含了哪些头文件，并且，你在加入或删除头文件时，也需要小心地修改Makefile，这是一个很没有维护性的工作。为了避免这种繁重而又容易出错的事情，我们可以使用C/C++编译的一个功能。大多数的C/C++编译器都支持一个“-M”的选项，即自动找寻源文件中包含的头文件，并生成一个依赖关系。例如，如果我们执行下面的命令： cc -M main.c 其输出是： main.o : main.c defs.h 于是由编译器自动生成的依赖关系，这样一来，你就不必再手动书写若干文件的依赖关系，而由编译器自动生成了。需要提醒一句的是，如果你使用GNU的C/C++编译器，你得用“-MM”参数，不然，“-M”参数会把一些标准库的头文件也包含进来。 gcc -M main.c的输出是： main.o: main.c defs.h /usr/include/stdio.h /usr/include/features.h \ /usr/include/sys/cdefs.h /usr/include/gnu/stubs.h \ /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stddef.h \ /usr/include/bits/types.h /usr/include/bits/pthreadtypes.h \ /usr/include/bits/sched.h /usr/include/libio.h \ /usr/include/_G_config.h /usr/include/wchar.h \ /usr/include/bits/wchar.h /usr/include/gconv.h \ /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stdarg.h \ /usr/include/bits/stdio_lim.h gcc -MM main.c的输出则是： main.o: main.c defs.h 那么，编译器的这个功能如何与我们的Makefile联系在一起呢。因为这样一来，我们的Makefile也要根据这些源文件重新生成，让Makefile自已依赖于源文件？这个功能并不现实，不过我们可以有其它手段来迂回地实现这一功能。GNU组织建议把编译器为每一个源文件的自动生成的依赖关系放到一个文件中，为每一个“name.c”的文件都生成一个“name.d”的Makefile文件，[.d]文件中就存放对应[.c]文件的依赖关系。 于是，我们可以写出[.c]文件和[.d]文件的依赖关系，并让make自动更新或自成[.d]文件，并把其包含在我们的主Makefile中，这样，我们就可以自动化地生成每个文件的依赖关系了。 这里，我们给出了一个模式规则来产生[.d]文件： %.d: %.c @set -e; rm -f $@; \ $(CC) -M $(CPPFLAGS) $< >; $@.$$$$; \ sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ >; $@; \ rm -f $@.$$$$ 这个规则的意思是，所有的[.d]文件依赖于[.c]文件，“rm -f $@”的意思是删除所有的目标，也就是[.d]文件，第二行的意思是，为每个依赖文件“$<”，也就是[.c]文件生成依赖文件，“$@”表示模式“%.d”文件，如果有一个C文件是name.c，那么“%”就是“name”，“$$$$”意为一个随机编号，第二行生成的文件有可能是“name.d.12345”，第三行使用sed命令做了一个替换，关于sed命令的用法请参看相关的使用文档。第四行就是删除临时文件。 总而言之，这个模式要做的事就是在编译器生成的依赖关系中加入[.d]文件的依赖，即把依赖关系： main.o : main.c defs.h 转成： main.o main.d : main.c defs.h 于是，我们的[.d]文件也会自动更新了，并会自动生成了，当然，你还可以在这个[.d]文件中加入的不只是依赖关系，包括生成的命令也可一并加入，让每个[.d]文件都包含一个完赖的规则。一旦我们完成这个工作，接下来，我们就要把这些自动生成的规则放进我们的主Makefile中。我们可以使用Makefile的“include”命令，来引入别的Makefile文件（前面讲过），例如： sources = foo.c bar.c include $(sources:.c=.d) 上述语句中的“$(sources:.c=.d)”中的“.c=.d”的意思是做一个替换，把变量$(sources)所有[.c]的字串都替换成[.d]，关于这个“替换”的内容，在后面我会有更为详细的讲述。当然，你得注意次序，因为include是按次来载入文件，最先载入的[.d]文件中的目标会成为默认目标。 gunguymadman 回复于：2004-09-16 12:21:21 书写命令 ———— 每条规则中的命令和操作系统Shell的命令行是一致的。make会一按顺序一条一条的执行命令，每条命令的开头必须以[Tab]键开头，除非，命令是紧跟在依赖规则后面的分号后的。在命令行之间中的空格或是空行会被忽略，但是如果该空格或空行是以Tab键开头的，那么make会认为其是一个空命令。 我们在UNIX下可能会使用不同的Shell，但是make的命令默认是被“/bin/sh”——UNIX的标准Shell解释执行的。除非你特别指定一个其它的Shell。Makefile中，“#”是注释符，很像C/C++中的“//”，其后的本行字符都被注释。 一、显示命令 通常，make会把其要执行的命令行在命令执行前输出到屏幕上。当我们用“@”字符在命令行前，那么，这个命令将不被make显示出来，最具代表性的例子是，我们用这个功能来像屏幕显示一些信息。如： @echo 正在编译XXX模块...... 当make执行时，会输出“正在编译XXX模块......”字串，但不会输出命令，如果没有“@”，那么，make将输出： echo 正在编译XXX模块...... 正在编译XXX模块...... 如果make执行时，带入make参数“-n”或“--just-print”，那么其只是显示命令，但不会执行命令，这个功能很有利于我们调试我们的Makefile，看看我们书写的命令是执行起来是什么样子的或是什么顺序的。 而make参数“-s”或“--slient”则是全面禁止命令的显示。 二、命令执行 当依赖目标新于目标时，也就是当规则的目标需要被更新时，make会一条一条的执行其后的命令。需要注意的是，如果你要让上一条命令的结果应用在下一条命令时，你应该使用分号分隔这两条命令。比如你的第一条命令是cd命令，你希望第二条命令得在cd之后的基础上运行，那么你就不能把这两条命令写在两行上，而应该把这两条命令写在一行上，用分号分隔。如： 示例一： exec: cd /home/hchen pwd 示例二： exec: cd /home/hchen; pwd 当我们执行“make exec”时，第一个例子中的cd没有作用，pwd会打印出当前的Makefile目录，而第二个例子中，cd就起作用了，pwd会打印出“/home/hchen”。 make一般是使用环境变量SHELL中所定义的系统Shell来执行命令，默认情况下使用UNIX的标准Shell——/bin/sh来执行命令。但在MS-DOS下有点特殊，因为MS-DOS下没有SHELL环境变量，当然你也可以指定。如果你指定了UNIX风格的目录形式，首先，make会在SHELL所指定的路径中找寻命令解释器，如果找不到，其会在当前盘符中的当前目录中寻找，如果再找不到，其会在PATH环境变量中所定义的所有路径中寻找。MS-DOS中，如果你定义的命令解释器没有找到，其会给你的命令解释器加上诸如“.exe”、“.com”、“.bat”、“.sh”等后缀。 三、命令出错 每当命令运行完后，make会检测每个命令的返回码，如果命令返回成功，那么make会执行下一条命令，当规则中所有的命令成功返回后，这个规则就算是成功完成了。如果一个规则中的某个命令出错了（命令退出码非零），那么make就会终止执行当前规则，这将有可能终止所有规则的执行。 有些时候，命令的出错并不表示就是错误的。例如mkdir命令，我们一定需要建立一个目录，如果目录不存在，那么mkdir就成功执行，万事大吉，如果目录存在，那么就出错了。我们之所以使用mkdir的意思就是一定要有这样的一个目录，于是我们就不希望mkdir出错而终止规则的运行。 为了做到这一点，忽略命令的出错，我们可以在Makefile的命令行前加一个减号“-”（在Tab键之后），标记为不管命令出不出错都认为是成功的。如： clean: -rm -f *.o 还有一个全局的办法是，给make加上“-i”或是“--ignore-errors”参数，那么，Makefile中所有命令都会忽略错误。而如果一个规则是以“.IGNORE”作为目标的，那么这个规则中的所有命令将会忽略错误。这些是不同级别的防止命令出错的方法，你可以根据你的不同喜欢设置。 还有一个要提一下的make的参数的是“-k”或是“--keep-going”，这个参数的意思是，如果某规则中的命令出错了，那么就终目该规则的执行，但继续执行其它规则。 四、嵌套执行make 在一些大的工程中，我们会把我们不同模块或是不同功能的源文件放在不同的目录中，我们可以在每个目录中都书写一个该目录的Makefile，这有利于让我们的Makefile变得更加地简洁，而不至于把所有的东西全部写在一个Makefile中，这样会很难维护我们的Makefile，这个技术对于我们模块编译和分段编译有着非常大的好处。 例如，我们有一个子目录叫subdir，这个目录下有个Makefile文件，来指明了这个目录下文件的编译规则。那么我们总控的Makefile可以这样书写： subsystem: cd subdir && $(MAKE) 其等价于： subsystem: $(MAKE) -C subdir 定义$(MAKE)宏变量的意思是，也许我们的make需要一些参数，所以定义成一个变量比较利于维护。这两个例子的意思都是先进入“subdir”目录，然后执行make命令。 我们把这个Makefile叫做“总控Makefile”，总控Makefile的变量可以传递到下级的Makefile中（如果你显示的声明），但是不会覆盖下层的Makefile中所定义的变量，除非指定了“-e”参数。 如果你要传递变量到下级Makefile中，那么你可以使用这样的声明： export <variable ...>; 如果你不想让某些变量传递到下级Makefile中，那么你可以这样声明： unexport <variable ...>; 如： 示例一： export variable = value 其等价于： variable = value export variable 其等价于： export variable := value 其等价于： variable := value export variable 示例二： export variable += value 其等价于： variable += value export variable 如果你要传递所有的变量，那么，只要一个export就行了。后面什么也不用跟，表示传递所有的变量。 需要注意的是，有两个变量，一个是SHELL，一个是MAKEFLAGS，这两个变量不管你是否export，其总是要传递到下层Makefile中，特别是MAKEFILES变量，其中包含了make的参数信息，如果我们执行“总控Makefile”时有make参数或是在上层Makefile中定义了这个变量，那么MAKEFILES变量将会是这些参数，并会传递到下层Makefile中，这是一个系统级的环境变量。 但是make命令中的有几个参数并不往下传递，它们是“-C”,“-f”,“-h”“-o”和“-W”（有关Makefile参数的细节将在后面说明），如果你不想往下层传递参数，那么，你可以这样来： subsystem: cd subdir && $(MAKE) MAKEFLAGS= 如果你定义了环境变量MAKEFLAGS，那么你得确信其中的选项是大家都会用到的，如果其中有“-t”,“-n”,和“-q”参数，那么将会有让你意想不到的结果，或许会让你异常地恐慌。 还有一个在“嵌套执行”中比较有用的参数，“-w”或是“--print-directory”会在make的过程中输出一些信息，让你看到目前的工作目录。比如，如果我们的下级make目录是“/home/hchen/gnu/make”，如果我们使用“make -w”来执行，那么当进入该目录时，我们会看到： make: Entering directory `/home/hchen/gnu/make'. 而在完成下层make后离开目录时，我们会看到： make: Leaving directory `/home/hchen/gnu/make' 当你使用“-C”参数来指定make下层Makefile时，“-w”会被自动打开的。如果参数中有“-s”（“--slient”）或是“--no-print-directory”，那么，“-w”总是失效的。 五、定义命令包 如果Makefile中出现一些相同命令序列，那么我们可以为这些相同的命令序列定义一个变量。定义这种命令序列的语法以“define”开始，以“endef”结束，如： define run-yacc yacc $(firstword $^) mv y.tab.c $@ endef 这里，“run-yacc”是这个命令包的名字，其不要和Makefile中的变量重名。在“define”和“endef”中的两行就是命令序列。这个命令包中的第一个命令是运行Yacc程序，因为Yacc程序总是生成“y.tab.c”的文件，所以第二行的命令就是把这个文件改改名字。还是把这个命令包放到一个示例中来看看吧。 foo.c : foo.y $(run-yacc) 我们可以看见，要使用这个命令包，我们就好像使用变量一样。在这个命令包的使用中，命令包“run-yacc”中的“$^”就是“foo.y”，“$@”就是“foo.c”（有关这种以“$”开头的特殊变量，我们会在后面介绍），make在执行命令包时，命令包中的每个命令会被依次独立执行。 gunguymadman 回复于：2004-09-16 12:22:15 使用变量 ———— 在Makefile中的定义的变量，就像是C/C++语言中的宏一样，他代表了一个文本字串，在Makefile中执行的时候其会自动原模原样地展开在所使用的地方。其与C/C++所不同的是，你可以在Makefile中改变其值。在Makefile中，变量可以使用在“目标”，“依赖目标”，“命令”或是Makefile的其它部分中。 变量的命名字可以包含字符、数字，下划线（可以是数字开头），但不应该含有“:”、“#”、“=”或是空字符（空格、回车等）。变量是大小写敏感的，“foo”、“Foo”和“FOO”是三个不同的变量名。传统的Makefile的变量名是全大写的命名方式，但我推荐使用大小写搭配的变量名，如：MakeFlags。这样可以避免和系统的变量冲突，而发生意外的事情。 有一些变量是很奇怪字串，如“$<”、“$@”等，这些是自动化变量，我会在后面介绍。 一、变量的基础 变量在声明时需要给予初值，而在使用时，需要给在变量名前加上“$”符号，但最好用小括号“（）”或是大括号“{}”把变量给包括起来。如果你要使用真实的“$”字符，那么你需要用“$$”来表示。 变量可以使用在许多地方，如规则中的“目标”、“依赖”、“命令”以及新的变量中。先看一个例子： objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects) $(objects) : defs.h 变量会在使用它的地方精确地展开，就像C/C++中的宏一样，例如： foo = c prog.o : prog.$(foo) $(foo)$(foo) -$(foo) prog.$(foo) 展开后得到： prog.o : prog.c cc -c prog.c 当然，千万不要在你的Makefile中这样干，这里只是举个例子来表明Makefile中的变量在使用处展开的真实样子。可见其就是一个“替代”的原理。 另外，给变量加上括号完全是为了更加安全地使用这个变量，在上面的例子中，如果你不想给变量加上括号，那也可以，但我还是强烈建议你给变量加上括号。 二、变量中的变量 在定义变量的值时，我们可以使用其它变量来构造变量的值，在Makefile中有两种方式来在用变量定义变量的值。 先看第一种方式，也就是简单的使用“=”号，在“=”左侧是变量，右侧是变量的值，右侧变量的值可以定义在文件的任何一处，也就是说，右侧中的变量不一定非要是已定义好的值，其也可以使用后面定义的值。如： foo = $(bar) bar = $(ugh) ugh = Huh? all: echo $(foo) 我们执行“make all”将会打出变量$(foo)的值是“Huh?”（ $(foo)的值是$(bar)，$(bar)的值是$(ugh)，$(ugh)的值是“Huh?”）可见，变量是可以使用后面的变量来定义的。 这个功能有好的地方，也有不好的地方，好的地方是，我们可以把变量的真实值推到后面来定义，如： CFLAGS = $(include_dirs) -O include_dirs = -Ifoo -Ibar 当“CFLAGS”在命令中被展开时，会是“-Ifoo -Ibar -O”。但这种形式也有不好的地方，那就是递归定义，如： CFLAGS = $(CFLAGS) -O 或： A = $(B) B = $(A) 这会让make陷入无限的变量展开过程中去，当然，我们的make是有能力检测这样的定义，并会报错。还有就是如果在变量中使用函数，那么，这种方式会让我们的make运行时非常慢，更糟糕的是，他会使用得两个make的函数“wildcard”和“shell”发生不可预知的错误。因为你不会知道这两个函数会被调用多少次。 为了避免上面的这种方法，我们可以使用make中的另一种用变量来定义变量的方法。这种方法使用的是“:=”操作符，如： x := foo y := $(x) bar x := later 其等价于： y := foo bar x := later 值得一提的是，这种方法，前面的变量不能使用后面的变量，只能使用前面已定义好了的变量。如果是这样： y := $(x) bar x := foo 那么，y的值是“bar”，而不是“foo bar”。 上面都是一些比较简单的变量使用了，让我们来看一个复杂的例子，其中包括了make的函数、条件表达式和一个系统变量“MAKELEVEL”的使用： ifeq (0,${MAKELEVEL}) cur-dir := $(shell pwd) whoami := $(shell whoami) host-type := $(shell arch) MAKE := ${MAKE} host-type=${host-type} whoami=${whoami} endif 关于条件表达式和函数，我们在后面再说，对于系统变量“MAKELEVEL”，其意思是，如果我们的make有一个嵌套执行的动作（参见前面的“嵌套使用make”），那么，这个变量会记录了我们的当前Makefile的调用层数。 下面再介绍两个定义变量时我们需要知道的，请先看一个例子，如果我们要定义一个变量，其值是一个空格，那么我们可以这样来： nullstring := space := $(nullstring) # end of the line nullstring是一个Empty变量，其中什么也没有，而我们的space的值是一个空格。因为在操作符的右边是很难描述一个空格的，这里采用的技术很管用，先用一个Empty变量来标明变量的值开始了，而后面采用“#”注释符来表示变量定义的终止，这样，我们可以定义出其值是一个空格的变量。请注意这里关于“#”的使用，注释符“#”的这种特性值得我们注意，如果我们这样定义一个变量： dir := /foo/bar # directory to put the frobs in dir这个变量的值是“/foo/bar”，后面还跟了4个空格，如果我们这样使用这样变量来指定别的目录——“$(dir)/file”那么就完蛋了。 还有一个比较有用的操作符是“?=”，先看示例： FOO ?= bar 其含义是，如果FOO没有被定义过，那么变量FOO的值就是“bar”，如果FOO先前被定义过，那么这条语将什么也不做，其等价于： ifeq ($(origin FOO), undefined) FOO = bar endif 三、变量高级用法 这里介绍两种变量的高级使用方法，第一种是变量值的替换。 我们可以替换变量中的共有的部分，其格式是“$(var:a=b)”或是“${var:a=b}”，其意思是，把变量“var”中所有以“a”字串“结尾”的“a”替换成“b”字串。这里的“结尾”意思是“空格”或是“结束符”。 还是看一个示例吧： foo := a.o b.o c.o bar := $(foo:.o=.c) 这个示例中，我们先定义了一个“$(foo)”变量，而第二行的意思是把“$(foo)”中所有以“.o”字串“结尾”全部替换成“.c”，所以我们的“$(bar)”的值就是“a.c b.c c.c”。 另外一种变量替换的技术是以“静态模式”（参见前面章节）定义的，如： foo := a.o b.o c.o bar := $(foo:%.o=%.c) 这依赖于被替换字串中的有相同的模式，模式中必须包含一个“%”字符，这个例子同样让$(bar)变量的值为“a.c b.c c.c”。 第二种高级用法是——“把变量的值再当成变量”。先看一个例子： x = y y = z a := $($(x)) 在这个例子中，$(x)的值是“y”，所以$($(x))就是$(y)，于是$(a)的值就是“z”。（注意，是“x=y”，而不是“x=$(y)”） 我们还可以使用更多的层次： x = y y = z z = u a := $($($(x))) 这里的$(a)的值是“u”，相关的推导留给读者自己去做吧。 让我们再复杂一点，使用上“在变量定义中使用变量”的第一个方式，来看一个例子： x = $(y) y = z z = Hello a := $($(x)) 这里的$($(x))被替换成了$($(y))，因为$(y)值是“z”，所以，最终结果是：a:=$(z)，也就是“Hello”。 再复杂一点，我们再加上函数： x = variable1 variable2 := Hello y = $(subst 1,2,$(x)) z = y a := $($($(z))) 这个例子中，“$($($(z)))”扩展为“$($(y))”，而其再次被扩展为“$($(subst 1,2,$(x)))”。$(x)的值是“variable1”，subst函数把“variable1”中的所有“1”字串替换成“2”字串，于是，“variable1”变成“variable2”，再取其值，所以，最终，$(a)的值就是$(variable2)的值——“Hello”。（喔，好不容易） 在这种方式中，或要可以使用多个变量来组成一个变量的名字，然后再取其值： first_second = Hello a = first b = second all = $($a_$b) 这里的“$a_$b”组成了“first_second”，于是，$(all)的值就是“Hello”。 再来看看结合第一种技术的例子： a_objects := a.o b.o c.o 1_objects := 1.o 2.o 3.o sources := $($(a1)_objects:.o=.c) 这个例子中，如果$(a1)的值是“a”的话，那么，$(sources)的值就是“a.c b.c c.c”；如果$(a1)的值是“1”，那么$(sources)的值是“1.c 2.c 3.c”。 再来看一个这种技术和“函数”与“条件语句”一同使用的例子： ifdef do_sort func := sort else func := strip endif bar := a d b g q c foo := $($(func) $(bar)) 这个示例中，如果定义了“do_sort”，那么：foo := $(sort a d b g q c)，于是$(foo)的值就是“a b c d g q”，而如果没有定义“do_sort”，那么：foo := $(sort a d b g q c)，调用的就是strip函数。 当然，“把变量的值再当成变量”这种技术，同样可以用在操作符的左边： dir = foo $(dir)_sources := $(wildcard $(dir)/*.c) define $(dir)_print lpr $($(dir)_sources) endef 这个例子中定义了三个变量：“dir”，“foo_sources”和“foo_print”。 四、追加变量值 我们可以使用“+=”操作符给变量追加值，如： objects = main.o foo.o bar.o utils.o objects += another.o 于是，我们的$(objects)值变成：“main.o foo.o bar.o utils.o another.o”（another.o被追加进去了） 使用“+=”操作符，可以模拟为下面的这种例子： objects = main.o foo.o bar.o utils.o objects := $(objects) another.o 所不同的是，用“+=”更为简洁。 如果变量之前没有定义过，那么，“+=”会自动变成“=”，如果前面有变量定义，那么“+=”会继承于前次操作的赋值符。如果前一次的是“:=”，那么“+=”会以“:=”作为其赋值符，如： variable := value variable += more 等价于： variable := value variable := $(variable) more 但如果是这种情况： variable = value variable += more 由于前次的赋值符是“=”，所以“+=”也会以“=”来做为赋值，那么岂不会发生变量的递补归定义，这是很不好的，所以make会自动为我们解决这个问题，我们不必担心这个问题。 五、override 指示符 如果有变量是通常make的命令行参数设置的，那么Makefile中对这个变量的赋值会被忽略。如果你想在Makefile中设置这类参数的值，那么，你可以使用“override”指示符。其语法是： override <variable>; = <value>; override <variable>; := <value>; 当然，你还可以追加： override <variable>; += <more text>; 对于多行的变量定义，我们用define指示符，在define指示符前，也同样可以使用ovveride指示符，如： override define foo bar endef gunguymadman 回复于：2004-09-16 12:22:51 六、多行变量 还有一种设置变量值的方法是使用define关键字。使用define关键字设置变量的值可以有换行，这有利于定义一系列的命令（前面我们讲过“命令包”的技术就是利用这个关键字）。 define指示符后面跟的是变量的名字，而重起一行定义变量的值，定义是以endef关键字结束。其工作方式和“=”操作符一样。变量的值可以包含函数、命令、文字，或是其它变量。因为命令需要以[Tab]键开头，所以如果你用define定义的命令变量中没有以[Tab]键开头，那么make就不会把其认为是命令。 下面的这个示例展示了define的用法： define two-lines echo foo echo $(bar) endef 七、环境变量 make运行时的系统环境变量可以在make开始运行时被载入到Makefile文件中，但是如果Makefile中已定义了这个变量，或是这个变量由make命令行带入，那么系统的环境变量的值将被覆盖。（如果make指定了“-e”参数，那么，系统环境变量将覆盖Makefile中定义的变量） 因此，如果我们在环境变量中设置了“CFLAGS”环境变量，那么我们就可以在所有的Makefile中使用这个变量了。这对于我们使用统一的编译参数有比较大的好处。如果Makefile中定义了CFLAGS，那么则会使用Makefile中的这个变量，如果没有定义则使用系统环境变量的值，一个共性和个性的统一，很像“全局变量”和“局部变量”的特性。 当make嵌套调用时（参见前

GOOGLE全球副总裁李开复演讲的其他资料 A Customer's Plea - v3 0.ppt Advice_for_US_Companies_in_China.ppt BecomeAGoodSpeaker.ppt cas.ppt Conversational_UI.ppt Dot_Net.ppt MIT_Keynote.ppt MS_Success.ppt Natural_UI.ppt Speech_Technology.ppt Successful_Students.ppt Technology_Talents_Education.ppt wisdom_of_choosing.ppt 微软亚洲研究院创始人李开复在演讲.txt 李开复演讲及其他资料.txt

C和C++嵌入式系統編程 今天，差不多每个电子设备的设计都要用到嵌入式系统。嵌入式系统藏在我们的手表里，录像机里，微波炉、手机、呼机里；军事上使用嵌入式系统为导弹制导、侦察敌方的飞机；没有嵌入式系统，通信卫星、空间探测和现代机械也就无从谈起。每个嵌入式系统都是独特和高度专用的。因此，嵌入式系统编程涉及很广，需要长期的实践才能熟练掌握。但是，如果你有编程经验，熟悉C/C++语言，本书简洁明快的风格，大量来自实战的专家建议，将帮助你快速登堂入室。 本书中的技术和范例代码均可直接应用于各种实际的嵌入式系统项目。有过嵌入式系统开发经验的读者，也将从中获益匪浅。本书内容包括： ● 快速有效的测试存储器芯片 ● 如何写入和擦除快闪存储器 ● 用循环冗余校验码验证非易失性存储器数据 ● 与芯片的内部外设和外部外设接口 ● 设计和实现设备驱动 ● 优化嵌入式软件 ● 最大限度高性能的应用C++特性 本书适用于嵌入式系统程序员、设计师和项目管理人员。 "这本清新可读的书是一本嵌入式系统开发者的绝佳读物。它提供了嵌入式系统开发过程中所有必要的主题。" -Lindsey Vereen,《Embedded Systems Programming》杂志主编 前言 第一章 引言 什么是嵌入式系统 各种实现间的差异 C：最基本的必需品 关于硬件的一些说明 第二章 你的第一个嵌入式程序 Hello，World! 闪烁程序（译注1） 无限循环的作用 第三章 编译、链接和定址 创建过程 编译 链接 定址 创建闪烁程序 在ROM中的时候…… 第四章 下载和调试 远程调试器 仿真器 模拟器和其他工具 第五章 接触硬件 理解全貌 检查一下环境 了解通信过程 接触处理器 研究扩展的外围设备 初始化硬件 第六章 存储器 存储器的类型 存储器的测试 验证存储器内容 使用快闪存储器 第七章 外围设备 控制和状态寄存器 设备驱动原理 ……

COM本质论(简体) 本书无疑是COM领域中最负有盛名的一本书。在亚马逊的排行榜上曾盘踞数月之久，很多专家给其以极高的评价。读完这本书之后，COM对于您会"变得再明白不过了"(这是"Inside OLE"的作者Kraig Brockschmidt和本书的作者DonBox在顿悟了COM和OLE之后的境界)。期望您会有这样的感受。 这不是一本供新手学习的书，也不是一本教您如何开发COM组件的书，而是一本在一定的基础上继续提高对COM的理解的书。如果用它来学习COM，您可能会失望，因为许多内容需要有一定的经验基础才能看得明白；但是如果用它来加深自己对COM的理解，那么这本书再合适不过了。 COM是跨语言的组件对象模型，但是它与C++和OO(面向对象)思想的渊源可谓深矣。本书会向您解释这些内容，但前提条件是您必须具备扎实的C++基础知识，特别要理解C++类的二进制结构以及类型转换机制。反过来，阅读本书也可以加强您在C++和OO思想方面的理解。此外，本书还涉及到许多COM高级特性，例如线程模型(或者套间模型)、名字对象、连接点等，因此，要想从本书获得最大受益，您也需要有COM的知识作基础，我建议读者先系统地学习COM之后再阅读本书(可以参看"COM技术内幕"或者"COM原理与应用")。

美河提供.Jython程序设计-美河提供.Jython程序设计

美河提供.Python编程指南美河提供.Python编程指南

[Bruce.Eckel编程思想系列丛书].Thinking.In.Java.Third.Edition.CHS

[Bruce.Eckel编程思想系列丛书].PRENTICE_HALL-Thinking_In_Java_Third_Edition

单片机C语言入门教程 学习单片机实在不是件易事，一来要购买高价格的编程器，仿真器，二来要学习编程语 言，还有众多种类的单片机选择真是件让人头痛的事。在众多单片机中51 架构的芯片风行很久，学习资料也相对很多，是初学的较好的选择之一。51 的编程语言常用的有二种，一种是汇编语言，一种是C 语言。汇编语言的机器代码生成效率很高但可读性却并不强，复杂一点的程序就更是难读懂，而C 语言在大多数情况下其机器代码生成效率和汇编语言相当，但可读性和可移植性却远远超过汇编语言，而且C 语言还可以嵌入汇编来解决高时效性的代码编写问题。对于开发周期来说，中大型的软件编写用C 语言的开发周期通常要小于汇编语言很多。综合以上C 语言的优点，我在学习时选择了C 语言。以后的教程也只是我在学习过程中的一些学习笔记和随笔，在这里加以整理和修改，希望和大家一起分享，一起交流，一起学习，一起进步。 *注：可以肯定的说这个教程只是为初学或入门者准备的，笔者本人也只是菜鸟一只， 第一课 建立您的第一个C 项目使用C 语言肯定要使用到C 编译器，以便把写好的C 程序编译为机器码，这样单片机 才能执行编写好的程序。KEIL uVISION2 是众多单片机应用开发软件中优秀的软件之一，它支持众多不同公司的MCS51 架构的芯片，它集编辑，编译，仿真等于一体，同时还支持，PLM，汇编和C 语言的程序设计，它的界面和常用的微软VC++的界面相似，界面友好，易学易用，在调试程序，软件仿真方面也有很强大的功能。因此很多开发51 应用的工程师或普通的单片机爱好者，都对它十分喜欢。 以上简单介绍了KEIL51 软件，要使用KEIL51 软件，必需先要安装它。KEIL51 是一个 商业的软件，对于我们这些普通爱好者可以到KEIL 中国代理周立功公司的网站上下载一份能编译2K 的DEMO 版软件，基本可以满足一般的个人学习和小型应用的开发。（安装的方法和普通软件相当这里就不做介绍了） 安装好后，您是不是迫不及待的想建立自己的第一个C 程序项目呢？下面就让我们一 起来建立一个小程序项目吧。或许您手中还没有一块实验板，甚至没有一块单片机，不过没有关系我们可以通过KEIL 软件仿真看到程序运行的结果。 首先当然是运行KEIL51 软件。怎么打开？噢，天！那您要从头学电脑了。呵呵，开个 玩笑，这个问题我想读者们也不会提的了：P。运行几秒后，出现如图1－1 的屏幕。

This is a manual for people who are developing Tcl code for Wish or any other Tcl application. It describes a set of conventions for writing code and the associated test scripts. There are three reasons for the conventions. First, the conventions ensure that certain important things get done; for example, every procedure must have documentation that describes each of its arguments and its result, and there must exist test scripts that exercise every line of code. Second, the conventions guarantee that all of the Tcl and Tk code has a uniform style. This makes it easier for us to use, read, and maintain each other’s code. Third, the conventions help to avoid some common mistakes by prohibiting error-prone constructs such as building lists by hand instead of using the list building procedures. This document is based heavily on the Tcl/Tk Engineering Manual written by John Ousterhout. John’s engineering manual specified the style of the C code used in the implementation of Tcl/Tk and many of its extensions. The manual is very valuable to the development of Tcl/Tk and is an important reason why Tcl is a relatively easy system to maintain. Deciding any style standard involves making trade-offs that are usually subjective. This standard was created in an iterative process involving the Tcl/Tk group at Sun Laboratories. I don’t claim that these conventions are the best possible ones, but the exact conventions don’t really make that much difference. The most important thing is that we all do things the same way. Please write your code so that it conforms to the conventions from the very start. For example, don’t write comment-free code on the assumption that you’ll go back and put the comments in later once the code is working. This simply won’t happen. Regardless of how good your intentions are, when it comes time to go back and put in the comments you’ll find that you have a dozen more important things to do; as the body of uncommented code builds up, it will be harder and harder to work up the energy to go back and fix it all. One of the fundamental rules of software is that its structure only gets worse over time; if you don’t build it right to begin with, it will never get that way later. The rest of this document consists of 8 major parts. We start with Section 2 which discusses executable files. Section 3 discusses the overall structure of packages and namespaces. Section 4 describes the structure of a Tcl code file and how to write procedure headers. Section 5 desribes the Tcl naming conventions. Section 6 presents low-level coding conventions, such as how to indent and where to put curly braces. Section 7 contains a collection of rules and suggestions for writing comments. Section 8 describes how to write and maintain test suites. Section 9 contains a few miscellaneous topics, such as keeping a change log.

This is a manual for people who are developing C code for Tcl, Tk, and their extensions and applications. It describes a set of conventions for writing code and the associated test scripts. There are two reasons for the conventions. First, the conventions ensure that certain important things get done; for example, every procedure must have documentation that describes each of its arguments and its result, and there must exist test scripts that exercise every line of code. Second, the conventions guarantee that all of the Tcl and Tk code has a uniform style. This makes it easier for us to use, read, and maintain each other’s code. Most of the conventions originated in the Sprite operating system project at U.C. Berkeley. At the beginning of the Sprite project my students and I decided that we wanted a uniform style for our code and documentation, so we held a series of meetings to choose the rules. The result of these meetings was a document called The Sprite Engineering Manual. None of us was completely happy with all the rules, but we all managed to live by them during the project and I think everyone was happy with the results. When I started work on Tcl and Tk, I decided to stick with the Sprite conventions. This document is based heavily on The Sprite Engineering Manual. There are few things that I consider non-negotiable, but the contents of this manual are one of them. I don’t claim that these conventions are the best possible ones, but the exact conventions don’t really make that much difference. The most important thing is that we all do things the same way. Given that the core Tcl and Tk code follows the conventions, changing the rules now would cause more harm than good. Please write your code so that it conforms to the conventions from the very start. For example, don’t write comment-free code on the assumption that you’ll go back and put the comments in later once the code is working. This simply won’t happen. Regardless of how good your intentions are, when it comes time to go back and put in the comments you’ll find that you have a dozen more important things to do; as the body of uncommented code builds up, it will be harder and harder to work up the energy to go back and fix it all. One of the fundamental rules of software is that its structure only gets worse over time; if you don’t build it right to begin with, it will never get that way later. When I write code I typically write the procedure headers for a whole file before I fill in any of the bodies. The rest of this document consists of 8 major parts. Section 2 discusses the overall structure of a package and how to organize header files. Section 3 describes the structure of a C code file and how to write procedure headers. Section 4 desribes the Tcl/Tk naming conventions. Section 5 presents low-level coding conventions, such as how to indent and where to put curly braces. Section 6 contains a collection of rules and suggestions for writing comments. Section 7 describes how to write and maintain test suites. Section 8 describes how to make code portable without making it unreadable too. Section 9 contains a few miscellaneous topics, such as keeping a change log.

目 录 前 言................................................................................................................................... 6 第1 章 文件结构............................................................................................................... 11 1.1 版权和版本的声明................................................................................................... 11 1.2 头文件的结构........................................................................................................... 12 1.3 定义文件的结构....................................................................................................... 13 1.4 头文件的作用........................................................................................................... 13 1.5 目录结构.................................................................................................................. 14 第2 章 程序的版式........................................................................................................... 15 2.1 空行.......................................................................................................................... 15 2.2 代码行...................................................................................................................... 16 2.3 代码行内的空格....................................................................................................... 17 2.4 对齐.......................................................................................................................... 18 2.5 长行拆分.................................................................................................................. 19 2.6 修饰符的位置........................................................................................................... 19 2.7 注释.......................................................................................................................... 20 2.8 类的版式.................................................................................................................. 21 第3 章 命名规则............................................................................................................... 22 3.1 共性规则.................................................................................................................. 22 3.2 简单的WINDOWS 应用程序命名规则...................................................................... 23 3.3 简单的UNIX 应用程序命名规则.............................................................................. 25 第4 章 表达式和基本语句................................................................................................ 26 4.1 运算符的优先级....................................................................................................... 26 4.2 复合表达式............................................................................................................... 27 4.3 IF 语句...................................................................................................................... 27 4.4 循环语句的效率....................................................................................................... 29 4.5 FOR 语句的循环控制变量......................................................................................... 30 4.6 SWITCH 语句.............................................................................................................. 30 4.7 GOTO 语句.................................................................................................................. 31 第5 章 常量....................................................................................................................... 33 5.1 为什么需要常量....................................................................................................... 33 5.2 CONST 与 #DEFINE 的比较........................................................................................ 33 5.3 常量定义规则........................................................................................................... 33 5.4 类中的常量............................................................................................................... 34 第6 章 函数设计............................................................................................................... 36 高质量C++/C 编程指南，v 1.0 2001 Page 4 of 101 6.1 参数的规则............................................................................................................... 36 6.2 返回值的规则........................................................................................................... 37 6.3 函数内部实现的规则............................................................................................... 39 6.4 其它建议.................................................................................................................. 40 6.5 使用断言.................................................................................................................. 41 6.6 引用与指针的比较................................................................................................... 42 第7 章 内存管理............................................................................................................... 44 7.1 内存分配方式........................................................................................................... 44 7.2 常见的内存错误及其对策........................................................................................ 44 7.3 指针与数组的对比.................................................................................................... 45 7.4 指针参数是如何传递内存的？ ................................................................................. 47 7.5 FREE 和DELETE 把指针怎么啦？ .............................................................................. 50 7.6 动态内存会被自动释放吗？ .................................................................................... 50 7.7 杜绝“野指针” ....................................................................................................... 51 7.8 有了MALLOC/FREE 为什么还要NEW/DELETE ？...................................................... 52 7.9 内存耗尽怎么办？ ................................................................................................... 53 7.10 MALLOC/FREE 的使用要点...................................................................................... 54 7.11 NEW/DELETE 的使用要点........................................................................................ 55 7.12 一些心得体会......................................................................................................... 56 第8 章 C++函数的高级特性............................................................................................ 57 8.1 函数重载的概念....................................................................................................... 57 8.2 成员函数的重载、覆盖与隐藏................................................................................ 60 8.3 参数的缺省值........................................................................................................... 63 8.4 运算符重载............................................................................................................... 64 8.5 函数内联.................................................................................................................. 65 8.6 一些心得体会........................................................................................................... 68 第9 章 类的构造函数、析构函数与赋值函数................................................................. 69 9.1 构造函数与析构函数的起源.................................................................................... 69 9.2 构造函数的初始化表............................................................................................... 70 9.3 构造和析构的次序................................................................................................... 72 9.4 示例：类STRING 的构造函数与析构函数............................................................... 72 9.5 不要轻视拷贝构造函数与赋值函数......................................................................... 73 9.6 示例：类STRING 的拷贝构造函数与赋值函数........................................................ 73 9.7 偷懒的办法处理拷贝构造函数与赋值函数............................................................. 75 9.8 如何在派生类中实现类的基本函数......................................................................... 75 9.9 一些心得体会........................................................................................................... 77 第10 章 类的继承与组合.................................................................................................. 78 高质量C++/C 编程指南，v 1.0 2001 Page 5 of 101 10.1 继承........................................................................................................................ 78 10.2 组合........................................................................................................................ 80 第11 章 其它编程经验...................................................................................................... 82 11.1 使用CONST 提高函数的健壮性.............................................................................. 82 11.2 提高程序的效率..................................................................................................... 84 11.3 一些有益的建议

TCL_TK大全 Tcl / Tk 大全 1 一. Tcl / Tk简介 1 1．1 背景 1 1．2 定义 2 二. Tcl / Tk基础 3 2.1 交互方式 3 2.2 非交互方式 3 三. TCL总体结构图 4 四. 与其它语言的比较 4 五. TCL语法 5 5.1 Tcl 命令结构. 5 5.2 TCL 的注释 5 5.3 数据类型 6 5.4 变量 6 5.5 字符串的操作 8 5.6 引用和置换 10 5.7 流的控制 IF 和 SWITCH 12 5.8文件的输入输出和文件的信息 14 5.9 过程 16 六.工具箱 17 6.1 构件的介绍 17 6.2 创建构件 17 6.3 构件的选项 18 6.4 一个TCL./TK 构件的编程示例 18 七. 小结 20

Tcl_TK编程权威指南pdf 内容简介回到顶部↑Tcl/Tk是第一种能通过Windows、Macintosh和Solaris等主要平台处理企业级任务的脚本语言。本书共分为55章，依次详细讲述了Tcl基础、Tcl高级特性、TK基础、TK组件、TK详解、C语言编程、各版本之间的差异等方面的知识，并通过大量实例，生动翔实地向读者介绍了Tcl/Tk编程，是读者掌握Tcl/Tt的必备参考书。 本书适合各个层次的读者阅读。 目录回到顶部↑第1部分　tcl基础 第1章　tcl的基本知识 tcl命令 hello，world! 变量 命令替换 数学表达式 反斜杠替换 使用花括号和双引号进行分组 过程 一个阶乘的例子 更多有关变量的知识 更多有关数学表达式的内容 注释 有关替换与分组的总结 要点 参考 第2章　开始使用 source命令 unix上的tcl脚本程序 .windows 95的开始菜单 macintosh与resedit console命令 命令行变元 预定义变量 第3章　cgi应用程序--顾客留言簿 html简介 使用cgi创建动态页面 guestbook．cgi脚本程序 定义表单以及处理表单数据 cgi．tcl软件包 接下去的几步 第4章　tcl中的字符串处理 string命令 append命令 format命令 scan命令 binary命令 相关章节 第5章　tcl列表 tcl列表 构建列表 获取列表元素 修改列表 搜索列表 对列表进行排序 split命令 join命令 相关章节 第6章 控制结构命令 if then else switch while foreach for break与continue catch error return 第7章　过程与作用域 proc命令 使用rename来改变命令名 作用域 global命令 通过upvar以名字进行调用 使用upvar来处理变量别名 第8章　tcl数组 数组的语法 array命令 使用数组来构建数据结构 第9章　对文件和程序的操作 使用exec运行程序 file命令 跨平台的文件命名方式 操作文件和目录 文件属性 对i/o命令的总结 打开文件用于i/o操作 读写操作 当前目录-cd和pwd 使用glob来匹配文件名 exit和pid命令 环境变量 registry命令 第2部分tcl高级特性 第10章 引用问题与eval 使用list命令来构建代码 在eval内部利用concat uplevel命令 subst命令 第11章　正则表达式 何时使用正则表达式 正则表达式的语法 高级正则表达式(are) 语法总结 regexp命令 rgsub命令 使用regsub将数据转换为程序 其他使用正则表达式的命令 第12章　脚本库及软件包 确定软件包的位置：auto-path变量 使用软件包 对软件包加载的总结 package命令 基于文件tclindex的库 unknown命令 方便交互 tclshell的库环境 编码风格 第13章　反射与调试 clock命令 info命令 跨平台支持 跟踪变量的值 交互式命令历史记录 调试 scriptics的tclpro 其他工具 性能调校 第14章　名字空间 使用名字空间 名字空间变量 命令查找 嵌套名字空间 过程的进口与输出 回调与名字空间 内省(introspection) namespace命令 转换现有的软件包以使用名字空间 [incrtcl]对象系统 注意事项 第15章　国际化(internationalization) 字符集与编码 消息目录 第16章　事件驱动的编程 tcl事件循环 after命令 fileevent命令 vwait命令 fconfigure命令 第17章　套接字编程 客户端套接字 服务器端套接字 回送(echo)服务 使用http获取一个url http软件包 基本认证 第18章 tclhttpd web服务器 将 tclhttpd与你的应用程序集成 域处理程序 应用执导的url 文档类型 html＋tcl模板 表单处理程序 编程参考 标准应用执导（application－dirct）的url tclhttpd发行版 服务器配置 第19章　多解释器与 safe-tcl interp命令 创建解释器 安全解释器 命令别名 隐藏命令 替换 从安全解释器中执行i／o操作 安全基础 安全策略 第20章　safe－tk与浏览器插件 子解释器中的tk 浏览器插件 安全策略与浏览器插件 配置安全策略 第3部分　tk基础 第21章　tk的基本知识 th中的hello，world！ tk组件的命名 配置tk组件 tk组件属性与资源数据库 tk命令概要 第22章　tk实例解析 execlog example browser tcl shell 第23章　打包摆放布局管理器（pack） 朝一侧摆放 水平与垂直难叠 空腔模型（ cavity model） 打包摆放空间（packing space）与显w空间（display space） 尺寸调整与一expand 挂靠 摆放顺序 选择用于摆放的父组件 取消一个组件的摆放 打包器总结 窗口的堆叠顺序 第24章　栅格摆放布局管理器（ grid） 一种基本栅格 跨行列摆放 行列约束 grid命令 第25　章定位摆放布局管理器（ place） place的基础知识 面板管理器 place命令 第26章　将命令与事件编联 bind命令 bindtags命令 事件的语法 修饰符 事件序列 虚拟事件 事件关键词 第4部分　tk组件 第27章　按钮与菜单 按钮命令与作用域问题 与tcl变量关联的按钮 按钮属性 按钮操作 菜单和菜单按钮 键盘遍历 操纵菜单和菜单条目 菜单属性 通过名字来指定菜单的软件包 第28章　资源数据库 有关资源的介绍 加载选项数据库 添加单一的数据库条目 存取数据库 用户定义的按钮 用户定义的菜单 第29章　简单的tk组件 框架组件与顶层窗口 标签组件 消息组件 标尺组件 bell命令 第30章　滚动条 使用滚动条 滚动条协议 滚动条组件 第31章　输入条组件 使用输入条组件 输入条组件 第32章　列表框组件 使用列表框组件 列表框组件的编联 列表框组件的属性 第33章　文本组件 文本索引 文本标记 文本标签 文本信息的选择（ selection） 标签的编联 文本搜索 嵌入组件 图片的嵌入 查看文本组件的内部信息 文本组件的编联 文本组件的操作 文本组件的属性 第34章　画布组件 画布坐标 hello， world！ 最小和最大标尺的例子 画布对象 画布组件的操作 产生postscript输出 画布组件的属性 建议 第5部分　tk详解 第35章 选择和剪贴板 选择模型 selection命令 clipboard命令 选择处理程序 第36章 焦点、焦点的捕获和对话框 标准对话框 定制对话框 使用update命令实现动画 第37章　tk组件的属性 配置属性 尺寸 边界与浮雕效果 焦点的高亮显示 补自（padding）与挂靠（anchor） 第38章　颜色、图片和鼠标指针 颜色 色彩映射与视频种类 位图和图片 文本插入光标 鼠标指针 第39章　字体与文本属性 字体命名 x字体名 字模 font命令 文本属性 栅格化、尺寸调整和布局 一个字体选择应用程序 第40章　send send命令 发送者脚本 通信进程 通过套接字来实现远程eval 第41章　窗口管理器与窗口信息 win命令 winfo命令 tk命令 第42章　管理用户首选项 应用默认设置文件 定义首选项 首选项的用户界面 管理首选项文件 跟踪对首选项变量的修改 对该软件包的改进 第43章　一种操作编联的用户界面 一对协调工作的列表框 编辑界面 保存与加载编联 第6部分　c语言编程 第44章　c语言编程与tcl 基本概念 创建可加载软件包 一个用c语言实现的命令过程 blob命令的例于 字符串与国际化 tolmain和tcl-applnit tk_main 事件循环 从c中调用脚本 第45章　编译tci及扩展模块 标准目录结构 从源代码建立tci 使用占位函数库（stub library） 使用autoconf 扩展模块范例 makefile.in 第46章　使用c语言编写tk组件 初始化扩展模块 组件的数据结构 组件的类命令 组件实例命令 配置和重新配置属性 指定组件属性 时钟的显示 窗口事件过程 最后的清除工作 第47章　c函数库概览 tclc函数库概览 tk c函数库概览 第7部分　各版本之间的差异 第48章 tcl 7.4/tk 4．0 wish 过时废弃的功能 cgct操作 输入焦点的高亮显示 编联 滚动条接日 pack info 焦点 send命令 按钮的内部补白 单选按钮的值 输入条组件 菜单 列表框 没有了geometry属性 文本组件 颜色属性 颜色分配与tk colormodel 画布组件的scrollincrement 选择 bell命令 第49章 tcl 7.5/tk 4.1 跨平台脚本 clock命令 load命令 package命令 多个foreach循环变量 事件循环从tk转移到了tcl 网络套接字 多解释器与safe－tcl grid布局管理器 文本组件 输入条组件 第50章 tcl7．6/tk 4．2 更多的file操作 虚拟事件 标准对话框 新的grid布局管理器 macintosh的unsupportedl命令 第51章 tcl/tk 8．0 tcl编译器 名字空间 safe－tcl 新的lsort tcl_precision变量 2000年约定 http软件包 串行线i/o 独立于平台的字体 tk scaling命令 应用程序的嵌入 本地化菜单与菜单条 cde的边界宽度 本地化的按钮和滚动条 文本组件中的图片 destroy不再产生错误 grid rowconfigure 补丁版本 第52章　tcl/tk 8．1 unicode与国际化 线程安全 高级正则表达式 新字符串命令 dde扩展模块 杂类 第53章 tcl/tk 8．2 trf补丁 更快的字符串操作 空数组名 浏览器插件的兼容性 第54章　tcl/tk 8．3 关于tcl的修改建议 关于tk的改动建议 第55章　有关本书的cd－rom ↓展开全部内容 序言回到顶部↑Tcl为工具命令语言(Tool Command Language)的缩写。它其实是指两样东西：一种脚本语言，以及该脚本语言的解释器。该解释器可以很容易地嵌入到你的应用程序中。Tcl和与之关联的图形用户界面工具包(Tk)是由加州大学的John Ousterhout教授设计并编写的。尽管它是个商用软件包，但你也可以在Internet上找到它(见第VII页)，而且可以在自己的应用程序中自由使用这个软件包。Tcl解释器已经从Unix平台移植到了DOS、Windows、OS／2、NT以及Macintosh环境中，而TK工具包也从X window系统移植到了Windows和Macintosh环境中。 1988年，当我在Berkeley做ousterhout教授的博士生时，第一次听说了Tcl。我们当时正在设计一种名为Sprite的网络操作系统。同学们在努力编制一个新式的内核程序，而John编写了一个新的编辑器和终端仿真程序。他使用Tcl作为这两种工具的命令语言，这样用户就可以定义菜单或者对那些程序进行定制。那时还处在使用X10的时代，他计划编写一个基于Tcl的X工具包，以使程序之间通过Tcl命令进行通信，彼此相互协作。对我来说，这种工具之间的相互协作就是Tcl的实质。 这种早期的设想就是让应用程序由包含编译代码的大块实体和一小部分用于进行配置和编写高级命令的Tcl代码组成。John的编辑器皿，还有终端仿真程序tx就遵循了这种模式。虽然这种模式仍然是有效的，但结果表明用Tcl来编写整个应用程序也是可能的。这是因为Tcl／Tk的shell程序wish提供了对其他程序、文件系统和网络套接字的存取功能，同时还能够创建图形用户界面。不管怎样，现在发现包含几千行Tcl脚本的应用程序并不稀奇。 我编写这本书的原因就是，虽然自己觉得使用Tcl与Tk既有乐趣又高效，但是也有令人头痛的时候。此外，在Xerox PARC工作，那里有许多语言和系统上的专家，我不得不强迫自己去理解Tcl/Tk的长处和弱点。我的许多同事都在他们的项目中采用了Tcl和Tk，但是他们也很快指出了它的缺点。因此，我就总结了一套编程技巧以充分利用Tcl/Tk的强大功能，同时回避一些棘手的问题。这本书就是一本帮助你最大限度地利用Tcl/Tk并回避一些我所经历过的令人头痛的问题的实用编程指南。 我接触Tcl语言大概已经有10年的时间了，而本书的第一版也已经出版5年了。在过去的几年中，我一直在John Ousterhout的手下工作，最初是在Sun微系统公司，而现在是在Scriptics公司。我一直使自己在很大程度上保持着一个Tcl程序员的角色，而我们工作组中的其他人员则埋头于Tcl本身的C语言实现。我创建的应用程序有HTML编辑器、EMAIL比用户接口程序、Web服务器以及用户数据库，我们的商务应用就建立在它们的基础上。这些经历在本书中有所反映。本书的大部分内容是有关Tcl脚本编程的，而有关使用C语言来创建Tcl扩展模块的内容没有着重讲述。我有幸一直参与Tcl核心技术的开发活动，希望通过本书能够将自己使用Tcl时获得的切身体会表达出来。 为什么要使用Tcl 作为一种脚本语言，Tcl与其他的Unix shell语言，如Bourne Shell(sh)、C Shell(csh)、Korn Shell以及Perl类似。Shell程序可以让你执行其他的程序。它们提供了足够的可编程特性(变量、流程控制和过程)，使你可以将现有程序组装成符合自己需要的复杂的脚本程序。Shell程序非常适用于一些日常任务的自动化处理工作。 Tcl解释器可以很容易地添加到你的应用程序中，这种能力将它与其他的shell语言区分开来。Tcl扮演了一种扩展语言的角色，用来配置和定制应用程序。你没有必要再去为自己的新应用程序发明一种命令语言，或是费力为自己的工具提供某种用户可编程特性。其实，你可以通过添加一个Tcl解释器，来将自己的应用程序组织成一组操作原语，并使用这些原语来构造最符合用户需求的脚本程序。这样还可以允许其他的程序通过编程来控制你的应用程序，以使套装应用程序能够很好地在一起工作。 Tcl的C函数库拥有清晰的接口而且便于使用。该函数库实现了基本的解释器，它有一套实现变量、流程控制和过程的核心脚本命令，而且还有一组用来存取操作系统服务以运行其他程序、存取文件系统和使用网络套接字的命令。Tcl和Tk提供了一台可以在UNIX、Windows和Macintosh环境中可移植的"虚拟机"。 因为你的应用程序可以定义新的Tcl命令，所以Tcl虚拟机是可扩展的。这些命令与你的应用程序所提供的C或C++过程关联。结果应用程序就分割成一组用编译语言编写的原语，并输出成为相应的Tcl命令。使用Tcl脚本程序可以将这些原语组装成完整的应用程序。脚本语言层可以存取与shell类似的功能以运行其他的程序，可以存取文件系统，还可以直接通过自己定义的Tcl命令来调用应用程序中编译的代码部分。此外，从C编程的层面上来说，你还可以调用Tcl脚本程序、设置和询问Tcl变量，甚至跟踪Tcl解释器的执行。 在Internet上有许多可自由使用的Tcl扩展模块。许多扩展模块都包含了一个提供某种新功能的C函数库，以及该函数库的Tcl接口。这样的例子包括数据库存取、电话控制、MIDI控制器存取，还有expect，它为控制交互式程序增加了一组Tcl命令。 最为著名的扩展模块就是Tk，这是一种图形用户界面工具包。Tk定义了用来创建和操作用户界面组件的Tcl命令。这种基于脚本的用户界面编程方法有三个好处： ． 由于快速的响应周期，所以开发迅速，不存在漫长的编译等待过程。 ． Tcl命令提供了一种比绝大多数由标准C函数库实现的用户界面工具包更为高级的接口。它只需一小组命令就可以定义简单的用户界面，同时又可以对用户界面进行细化以恰当地实现每一个细节。快速的响应周期又为这种细化过程提供了帮助。 用户界面处理可以从你的应用程序的其余部分分离出来。因而开发人员能够专心致志地实现应用程序的核心部分，然后再颇为轻松地构建出用户界面。Tk组件的核心功能通常能够满足你所有的用户界面需求。不过，你还可以用C语言来编写定制的Tk组件，而且网上还有许多大家提供的Tk组件可以使用。 还有其他可以用做扩展语言的选择，这包括VisualBasic、Scheme、Elisp、Perl；Python和Javascript等，你可以依照个人喜好从中进行选择。Tcl拥有简单的结构，而且还有些地方类似于C语言，可以通过编制C过程来增添新的Tcl原语。Tcl非常易学，许多有关用户使用Tcl在很短的时间内(例如几个星期)就完成了相当难度的项目，并且他们以前压根就没有接触过Tcl。 当本书第一次出版时，Java轰动了计算机界。Java是一种极为优秀的系统编程语言，长远来看还有可能代替C和C什语言。这对Tcl来说挺好，它在设计时就被用来将由任意系统编程语言编写的构件粘连起来。Tcl过去被设计与C语言一起工作，但是现在已经被改造成能够与Java虚拟机一起工作。在我们提到"C或C++"的地方，现在也可以说"C、C++或Java"了，但是对于Java来说，其细节上还多少存在些差异。这本书并没有描述TcVJava接口，但是你可以在CD-ROM上找到TclBlend。TclBlend将Java虚拟机加载到你的Tc3应用程序中并允许你调用Java方法，它还可以让你使用Java而不是C或C十十来实现Tcl命令。 Javascript是一种来自于Netscape的语言，它被设计用来编写与w曲页面进行交互的脚本程序。由于Netscape的广泛使用，Javascript就显得很重要，然而Tcl提供了一种更为通用的脚本方案，可以在更为广泛的范围中使用。Tcl/Tk的Web浏览器插件提供了一种在浏览器中运行Tcl的方式，结果使得Tcl更像是一种Java的替代品而不是Javascript的替代品。该插件可以让你在浏览器中执行Tcl应用程序，而Javascript则为你提供了对浏览器和HTML显示的精细控制。这种插件将在第20章有所描述。TcI与Tk的版本 Tcl与Tk仍在继续演变。请参看http：／／www.beedub.com／book/来了解有关最新的Tcl版本的更新和消息。由于历史原因，Tcl与Tk曾各有各的版本号，但是它们成对发行，并一起工作。这本书的原始版本基于Tcl7．4和Tk 4.0并有几处引用了Tk 3．6的功能。第三版已经进行了更新，它反映了直到Tcl/Tk8．2以来所增添的各种新特性： ． Tcl7．5和Tk 4.1的最终发布在1996年5月。这些版本的特点是将Tk移植到了Windows和Macintosh环境。它引入了Safe-Tcl安全机制，以支持网络小应用程序(Applet)的 .安全执行。它还提供了对网络套接字的支持以及一种新的输入输出(I/O)子系统，以支持高性 能的事件驱动I/O。 ． Tcl7．6和Tk4．2的最终发布是在1996年的10月。这些版本包含了对S池-Tcl的改进，以及对在Tk 4．1中引进的grid布局管理器的改进。跨平台的支持包括虚拟事件(例如，以＜＜Copy＞＞宋代表＜Control-c＞＝、标准对话框，还有更多的文件操作命令。 ． Tcl 7.7和Tk 4．3是内部版本，用于开发NetscapeNavigator和MicrosoftInternetExplorer Web浏览器的Tcl/Tk插件。它们的开发工作实际上与Tcl7．6和Tk 4．2并行进行。Tcl/Tt插件已经发布了许多各种平台上的版本，其中包括Solaris／SPARC、Solaris/INTEL、SunOS、Linux、Digital UNIX、IRIX、HP／UX、Windows95、Windows NT以及Macintosh。该浏览器插件支持Web页面中的Tcl小应用程序(Applet)，同时使用Safe-Tcl复杂的安全机制来提供安全保证。 ． Tcl8．0为Tcl新增了一个运行时用的编译器，这个编译器提供了数倍于Tcl脚本的执行速度。Tcl8.0支持内嵌空字符的字符串。编译器对脚本来说是透明的，但是扩展模块编写入员需要学习一些新的C API才能发挥它的潜力。由于John Ousterhout从Sun微系统公司到了Scriptics公司，发布8．0版的时间推迟了几年。广泛使用的版本8．0p2是在1997年完成的，但是最终的补丁版本8.0.5直到1999年春才发布。 ． 在8．0时，Tk更改了版本号以与Tcl相匹配。Tk 8．0包含了一种新的独立于平台的字体机制，它还包含了本地化菜单和菜单条，以及更多的本地化组件，它们在Windows和Macintosh上拥有更好的本地化外观。 Tcl/Tk8．1新特性主要包括对Unicode的完整支持，以及线程安全，这样你就可以将Tcl嵌入到多线程的应用程序中。Unicode是一种新的正则表达式引擎，它提供了在Perl5中所能找到的所有功能。Tk为找到正确的用于显示Unicode字符的字体完成了卓越的工作，它还增加了一种信息目录设施，这样你就可以编写国际化的应用程序。Tcylk 8．1的发布史中还包括了Sun到Scriptics的过渡。第一个alpha版本完成于1997年秋，而最终的补丁版本完成于1999年5月。 Tcl/Tk 8．2主要是一个进行bug修正和稳固化的版本。它对TclC函数库API进行了几处微小增补，这样无须核心补丁程序也能支持更多的扩展模块。Tcl/Tk 8．2很快在1999年夏进入最终版本。 谁应当阅读本书 本书不仅适用于熟练的编程人员，同样也适用于初学者。对于初学者和熟练编程人员来说，我建议大家仔细学习一下策1章"Tcl的基本知识"。Tcl的编程模型被设计成一种简单的模式，它与许多编程语言存在差异。该模型基于字符串替换，你对这一点的正确理解很重要，这样才能避免在复杂情况下遇到麻烦。这本书的其余部分则包含了演示如何高效地使用Tcl与Tt的例子。每一章中都有对其中所描述的Tcl命令和Tk组件进行总结的表格，以供参考。 本书假定你有一些编程经验，但是你如果是个彻头彻尾的新手也能够读下去。对Unix shell的了解将会对你有所帮助，但这并不是必须的。在那些涉及Windows系统的地方，我会提供一些背景信息。第2章详细描述了在UNIX、Windows和Macintosh上使用Tcl与Tk的内容。 如何阅读本书 本书最好能在上机实习中使用，可以在计算机上尝试一下书中的例子。Tcl与Tk的命令手册尽管完整但却缺少上下文的的相关信息和例子，本书就试图填补在简明手册与现有的文档化或没有很好文档化的Tcl程序之间的空隙。 我推荐使用联机手册来查阅有关的Tcl/Tk命令。它为每个命令都提供了详细的参考指南，但是它没能提供完整的细节，这在每一次发布的版本中都有所不同。HTML版本的联机手册可以在随书的CD-ROM中找到。

Contents at a Glance Foreword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii About the Author . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi About the Technical Reviewers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxii Acknowledgments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiii Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiv ■CHAPTER 1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 ■CHAPTER 2 Structure of the NetBeans Platform . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 ■CHAPTER 3 The Module System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 ■CHAPTER 4 Actions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 ■CHAPTER 5 User Interface Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 ■CHAPTER 6 Lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 ■CHAPTER 7 File Access and Display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 ■CHAPTER 8 Graphical Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 ■CHAPTER 9 Reusable NetBeans Platform Components . . . . . . . . . . . . . . . . . . . . 175 ■CHAPTER 10 Internationalization and Localization . . . . . . . . . . . . . . . . . . . . . . . . . 205 ■CHAPTER 11 Real-World Application Development . . . . . . . . . . . . . . . . . . . . . . . . . 213 ■CHAPTER 12 Updating a NetBeans Platform Application . . . . . . . . . . . . . . . . . . . . 219 ■CHAPTER 13 Persistence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 ■CHAPTER 14 Web Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 ■CHAPTER 15 Extending the NetBeans IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 ■CHAPTER 16 From Eclipse RCP to the NetBeans Platform . . . . . . . . . . . . . . . . . . 279 ■CHAPTER 17 Tips and Tricks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 ■CHAPTER 18 Example: MP3 Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297 ■APPENDIX Important NetBeans Extension Points and Configuration DTDs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 ■INDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 vii Contents Foreword . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xvii About the Author . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi About the Technical Reviewers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxii Acknowledgments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiii Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiv ■CHAPTER 1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 What Is a Rich Client? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 What Is a Rich Client Platform? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Advantages of a Rich Client Platform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Reduction in Development Time. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 User Interface Consistency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Updating. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Platform Independence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Reusability and Reliability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Characteristics of the NetBeans Platform . . . . . . . . . . . . . . . . . . . . . . . . . . 4 User Interface Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Data Editor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Customization Display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Wizard Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 Data Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Internationalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Help System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 ■CHAPTER 2 Structure of the NetBeans Platform. . . . . . . . . . . . . . . . . . . . . . . . 7 NetBeans Platform Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 NetBeans Platform Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 NetBeans Runtime Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 viii ■CONTENTS NetBeans Classloader System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Module Classloader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 System Classloader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Original Classloader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 ■CHAPTER 3 The Module System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Module Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Module Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Regular. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Autoload. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Eager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Module Manifest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Module Layer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Order of Entries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 Instance Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Shadow Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Settings Files. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Creating and Using Your Own Contents . . . . . . . . . . . . . . . . . . . . . . . 29 Creating Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Versioning and Dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 Defining Dependencies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 Lifecycle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 Module Registry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 Using Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 Library Wrapper Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 Adding a Library to a Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 ■CONTENTS ix ■CHAPTER 4 Actions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 Providing Action Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 Always Enabled Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 CallableSystemAction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 CallbackSystemAction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 CookieAction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 General Context-Sensitive Action Classes . . . . . . . . . . . . . . . . . . . . . 55 Registering Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Shortcuts and Mnemonics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 ■CHAPTER 5 User Interface Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 Menu Bar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 Creating and Adding Menus and Menu Entries . . . . . . . . . . . . . . . . . 62 Inserting Separators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 Hiding Existing Menu Entries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 Creating a Custom Menu Bar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 Toolbars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 Creating Toolbars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 Configuring Toolbars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 Modification by the User . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 Creating Custom Toolbars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 Using Custom Control Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 Window System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 Customization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Window: TopComponent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 Docking Container: Mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 Groups of Windows: TopComponentGroup . . . . . . . . . . . . . . . . . . . . 83 Status Bar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Using the Status Bar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 Extending the Status Bar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 x ■CONTENTS Progress Bar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Displaying the Progress of a Task . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 Displaying the Progress of Many Related Tasks . . . . . . . . . . . . . . . . 90 Integrating a Progress Bar into Your Component . . . . . . . . . . . . . . . 92 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 ■CHAPTER 6 Lookup. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 Functionality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 Services and Extension Points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 Defining the Service Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 Loose Service Provisioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 Providing Multiple Service Implementations . . . . . . . . . . . . . . . . . . . 96 Ensuring Service Availability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 Global Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 Registering Service Providers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 Service Provider Configuration File. . . . . . . . . . . . . . . . . . . . . . . . . . 100 Services Folder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 Intermodule Communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 Java Service Loader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 ■CHAPTER 7 File Access and Display . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 File Systems API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 Data Systems API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 DataObject . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 DataObject Factory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 DataLoader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 Nodes API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 Node Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 Implementing Nodes and Children . . . . . . . . . . . . . . . . . . . . . . . . . . 126 Explorer & Property Sheet API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 ■CONTENTS xi ■CHAPTER 8 Graphical Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Dialogs API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Standard Dialogs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 Custom Dialogs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 Wizards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 MultiViews API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Visual Library API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 Structure of the Visual Library API . . . . . . . . . . . . . . . . . . . . . . . . . . 155 The Widget Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 Events and Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 The Scene: The Root Element . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164 ObjectScene: Model-View Relationship . . . . . . . . . . . . . . . . . . . . . . 167 Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 VMD: Visual Mobile Designer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 ■CHAPTER 9 Reusable NetBeans Platform Components . . . . . . . . . . . . . . 175 Help System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 Creating and Integrating a Helpset . . . . . . . . . . . . . . . . . . . . . . . . . 175 Adding Links to Help Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 Context-Sensitive Help. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 Opening the Help System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Output Window . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Navigator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 Properties Window . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 Providing Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 User-Defined Properties Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 Options Window . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 Providing an Options Panel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 Settings Administration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 Palette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 Defining and Adding Palette Components via the Layer File . . . . . 197 Creating a Palette from a Node Hierarchy . . . . . . . . . . . . . . . . . . . . 198 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 xii ■CONTENTS ■CHAPTER 10 Internationalization and Localization . . . . . . . . . . . . . . . . . . . . 205 String Literals in Source Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 String Literals in the Manifest File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 Internationalization of Help Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 Internationalizing Other Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Graphics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Any File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Folders and Files. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 Administration and Preparation of Localized Resources . . . . . . . . . . . . 211 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 ■CHAPTER 11 Real-World Application Development. . . . . . . . . . . . . . . . . . . . 213 Creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 Customization of Platform Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 Customizing the Launcher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215 Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 Distribution As a ZIP Archive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 Distribution via Java Web Start . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217 Mac OS X Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 ■CHAPTER 12 Updating a NetBeans Platform Application . . . . . . . . . . . . . . 219 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 The Auto Update Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219 The NBM File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 Update Centers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 Localized NBM Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 Configuring and Installing on the Client . . . . . . . . . . . . . . . . . . . . . . . . . . 225 New Update Center. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 Automatically Installing Updates . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227 ■CONTENTS xiii ■CHAPTER 13 Persistence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 Java DB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 Integrating Java DB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 Driver Registration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 Creating and Using a Database. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 Shutting Down a Database . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232 Database Development with the Help of the NetBeans IDE. . . . . . 232 Example Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Hibernate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 Setting Up the Hibernate Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . 245 Structure of the Example Application . . . . . . . . . . . . . . . . . . . . . . . . 246 Configuring Hibernate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 Mapping Objects to Relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 SessionFactory and Sessions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 Saving and Loading Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 Java Persistence API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 Hibernate and the Java Persistence API . . . . . . . . . . . . . . . . . . . . . 253 Java Persistence Configuration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254 Entity Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 EntityManagerFactory and EntityManager . . . . . . . . . . . . . . . . . . . . 257 Saving and Loading Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 ■CHAPTER 14 Web Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Creating a Web Service Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Using a Web Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 ■CHAPTER 15 Extending the NetBeans IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 Palettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 Defining and Registering Palette Entries . . . . . . . . . . . . . . . . . . . . . 270 Creating and Registering a PaletteController. . . . . . . . . . . . . . . . . . 272 Expanding Existing Palettes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273 Task List API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 xiv ■CONTENTS ■CHAPTER 16 From Eclipse RCP to the NetBeans Platform. . . . . . . . . . . . . 279 The NetBeans IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 Standard Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 Handling Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 From Eclipse Plugins to NetBeans Modules . . . . . . . . . . . . . . . . . . . . . . 280 Plugin: Lifecycle and Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 Plugin Information. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282 Images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 Settings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 Application Lifecycle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 Views and Editors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 ■CHAPTER 17 Tips and Tricks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 Asynchronous Initialization of Graphic Components . . . . . . . . . . . . . . . . 287 Undo/Redo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 Ending an Application’s Lifecycle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291 WarmUp Tasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 System Tray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 Desktop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 Logger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 LogManager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 Error Reports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 ■CHAPTER 18 Example: MP3 Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297 Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297 Creating the NetBeans Platform Application . . . . . . . . . . . . . . . . . . . . . . 299 Support for MP3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 Creating the JMF Module. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 Registering the MP3 Plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 MP3 File Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 ID3 Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 ID3 API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 ID3 Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 ■CONTENTS xv Media Library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 MP3 Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309 Service Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309 Service Provider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311 Playback of MP3 Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 User Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 Playlist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 Node View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 Node Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 TopComponent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 Drag-and-Drop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 Saving the Playlist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 ■APPENDIX Important NetBeans Extension Points and Configuration DTDs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 ■INDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337

LINUX设备驱动程序 内容简介 　　《LINUX设备驱动程序(第3版)》已针对Linux内核的2610版本彻底更新过了。内核的这个版本针对常见任务完成了合理化设计及相应的简化，如即插即用、利用sysfs文件系统和用户空间交互，以及标准总线上的多设备管理等等。要阅读并理解本书，您不必首先成为内核黑客；只要您理解C语言并具有Unix系统调用的一些背景知识即可。您将学到如何为字符设备、块设备和网络接口编写驱动程序。为此，《LINUX设备驱动程序(第3版)》提供了完整的示例程序，您不需要特殊的硬件即可编译和运行这些示例程序。《LINUX设备驱动程序(第3版)》还在单独的章节中讲述了PCI、USB和tty(终端)子系统。对期望了解操作系统内部工作原理的读者来讲，《LINUX设备驱动程序(第3版)》也深入阐述了地址空间、异步事件以及I/O等方面的内容。 编辑本段作者简介 　　JonahanCorbet早在1981年就开始接触BSDUnix的源代码。那时，科罗拉多大学的一名讲师让他“修正”其中的分页算法。从那时起直到现在。他深入研究了他所遇到的每一个系统，其中包括VAX、Sun、Arden以及x86系统的驱动程序。他在1993年第一次接触Linux系统，从此以后一直从事Linux的开发。Corbet先生是《LinuxWeeklyNews》的创始人和执行主编。他和妻子及两个孩子生活在科罗多州的玻尔得市。 编辑本段编辑推荐 　　《LINUX设备驱动程序(第3版)》详细介绍了Linux。如果您希望在Linux操作系统上支持计算机外部设备，或者在Linux上运行新的硬件，或者只是希望一般性地了解Linux内核的编程，就一定要阅读本书。本书描述了如何针对各种设备编写驱动程序，而在过去，这些内容仅仅以口头形式交流，或者零星出现在神秘的代码注释中。 编辑本段目录 　　前言 　　第一章设备驱动程序简介 　　设备驱动程序的作用 　　内核功能划分 　　设备和模块的分类 　　安全问题