这也是实际上很多开源代码发布的惯用方式：

1. 预编译的开发包：包含一些.dll文件和一些.lib文件。其中这里的.lib就是导入库，而不要错以为是静态库。但是引入方式和静态库一样，要在链接路 径上添加找到这些.lib的路径。而.dll则最好放到最后产生的应用程序exe执行文件相同的目录。这样运行时，就会自动调入动态链接库。

2. 用户自己编译： 下载的是源代码，按照readme自己编译。生成很可能也是.dll + .lib(导入库)的库文件

3. 如果你只有dll，并且你知道dll中函数的函数原型，那么你可以直接在自己程序中使用LoadLibary调入DLL文件，GetProcAddress

DLL： 
动 态链接库 (DLL) 是作为共享函数库的可执行文件。动态链接提供了一种方法，使进程可以调用不属于其可执行代码的函数。函数的可执行代码位于一个 DLL 中，该 DLL 包含一个或多个已被编译、链接并与使用它们的进程分开存储的函数。DLL 还有助于共享数据和资源。多个应用程序可同时访问内存中单个 DLL 副本的内容。 
动态链接与静态链接的不同之处在于它允许可执行模块（.dll 文件或 .exe 文件）仅包含在运行时定位 DLL 函数的可执行代码所需的信息。在静态链接中，链接器从静态链接库获取所有被引用的函数，并将库同代码一起放到可执行文件中。 
使用动态链接代替静态链接有若干优点。DLL 节省内存，减少交换操作，节省磁盘空间，更易于升级，提供售后支持，提供扩展 MFC 库类的机制，支持多语言程序，并使国际版本的创建轻松完成。

API 就是应用程序编程接口。它是能用来操作组件、应用程序或者操作系统的一组函数。典型的情况下，API 由一个或多个提供某种特殊功能的 DLL 组成。 
DLL 是一个文件，其中包含了在 Microsoft? Windows? 下运行的任何应用程序都可调用的函数。运行时，DLL 中的函数动态地链接到调用它的应用程序中。无论有多少应用程序调用 DLL 中的某个函数，在磁盘上只有一个文件包含该函数，且只在它调入内存时才创建该 DLL。 
您听到最多的 API 可能是 Windows API，它包括构成 Windows 操作系统的各种 DLL。每个 Windows 应用程序都直接或间接地与 Windows API 互动。Windows API 保证 Windows 下运行的所有应用程序的行为方式一致。 
注意 随着 Windows 操作系统的发展，现已发布了几个版本的 Windows API。Windows 3.1 使用 Win16 API。Microsoft? Windows NT?、Windows 95 和 Windows 98 平台使用 Microsoft? Win32? API。 
除 Windows API 外，其他一些 API 也已发布。例如，邮件应用程序编程接口 (MAPI) 是一组可用于编写电子邮件应用程序的 DLL。 
API 传统上是为开发 Windows 应用程序的 C 和 C++ 程序员编写的，但其他的编程语言（包括VBA）也可以调用 DLL 中的函数。因为大部分 DLL 主要是为 C 和 C++ 程序员编写和整理说明的，所以调用 DLL 函数的方法与调用 VBA 函数会有所不同。在使用 API 时必须了解如何给 DLL 函数传递参数。 
警告 调用 Windows API 和 其他 DLL 函数可能会给您的应用程序带来不良影响。从自己的代码中直接调用 DLL 函数时，您绕过了 VBA 通常提供的一些安全机制。如果在定义或调用 DLL 函数时出现错误（所有程序员都不可避免），可能会在应用程序中引起应用程序错误（也称为通用性保护错误，或 GPF）。最好的解决办法是在运行代码以前保存该项目，并确保了解 DLL 函数调用的原理。

LIB 创建标准库、导入库和导出文件，在生成 32 位程序时可将它们与 LINK 一起使用。LIB 从命令提示运行。 
可在下列几种模式下使用 LIB： 
生成或修改 COFF 库 
将成员对象提取到文件中 
创建导出文件和导入库 
这些模式是互斥的；每次只能以一种模式使用 LIB。

一 逻辑题

在一张东景照片上,人们分别戴着帽子,系着围巾和戴着者手套.只戴帽子的人数与只系围巾和只戴手套的人数相等:只有4人没有戴帽子:戴着帽子和系着围巾,但没有戴手套的有5人:只戴帽子的人数两倍于只系围巾者:未戴手套者8人,未系围巾者7人:三样东西都用上了的人比只戴帽子的人多一个.那么请问:多少人同时用上了帽子,围巾和手套?多少人只戴了手套?多少人只系了围巾?多少人既戴了帽子,又戴了手套,但没系围巾?多少人戴着手套?照片上一共有多少个人?

如果用纯代数的方法来做，就这样。
设：只戴帽子的人数为A，只围巾B，只手套C，只帽子围巾D，只帽子手套E，只围巾手套F，都带的G 得：
A=B+C（只戴帽子人数与只系围巾和只戴手套的人数和相等 ）
B+C+F=4 （只有4人没有戴帽子）
D=5（戴着帽子和系着围巾，但没有戴手套的有5人）
A=2B（只戴帽子的人数两倍于只系着巾）
A+B+D=8（未戴着手套者8人）
A+C+E=7（未系围巾者7人）
G=A+1 （三样东西都用上了的人比只戴帽子的人多一个）
从D=5 A=2B A+B+D=8 这3个式子开始解
最后得出A=2 B=1 C=1 D=5 E=4 F=2 G=3 



二 汉诺塔

#include<iostream>
#include<string>

using namespace std;

void Hanoi(int n,char A,char B,char C);

void main()
{
    Hanoi(5,'A','B','C');
}

void Hanoi(int n,char A,char B,char C)
{
    if(n==1)
        cout<<"Move top disk from peg "<<A<<" to peg "<<C<<endl;
    else
    {
        Hanoi(n-1,A,C,B);
        cout<<"Move top disk from peg "<<A<<" to peg "<<C<<endl;
        Hanoi(n-1,B,A,C);
    }
}

.h头文件是编译时必须的，lib是链接时需要的，dll是运行时需要的。

附加依赖项的是.lib不是.dll，若生成了DLL,则肯定也生成 LIB文件。如果要完成源代码的编译和链接，有头文件和lib就够了。如果也使动态连接的程序运行起来，有dll就够了。在开发和调试阶段，当然最好都有。

.h .lib .dll三者的关系是：

H文件作用是:声明函数接口 

DLL文件作用是: 函数可执行代码 

当我们在自己的程序中引用了一个H文件里的函数,编链器怎么知道该调用哪个DLL文件呢?这就是LIB文件的作用: 告诉链接器 调用的函数在哪个DLL中，函数执行代码在DLL中的什么位置 ，这也就是为什么需要附加依赖项 .LIB文件，它起到桥梁的作用。如果生成静态库文件，则没有DLL ，只有lib，这时函数可执行代码部分也在lib文件中

目前以lib后缀的库有两种，一种为静态链接库(Static Libary，以下简称“静态库”)，另一种为动态连接库(DLL，以下简称“动态库”)的导入库(Import Libary，以下简称“导入库”）。静态库是一个或者多个obj文件的打包 ，所以有人干脆把从obj文件生成lib的过程称为Archive，即合并到一起。比如你链接一个静态库，如果其中有错，它会准确的找到是哪个obj有错，即静态lib只是壳子。动态库一般会有对应的导入库，方便程序静态载入动态链接库 ，否则你可能就需要自己LoadLibary调入DLL文件，然后再手工GetProcAddress获得对应函数了。有了导入库，你只需要链接导入库后按照头文件函数接口的声明调用函数就可以了。导入库和静态库的区别很大，他们实质是不一样的东西。静态库本身就包含了实际执行代码、符号表等等，而对于导入库而言，其实际的执行代码位于动态库中，导入库只包含了地址符号表等，确保程序找到对应函数的一些基本地址信息。

一般的动态库程序有lib文件和dll文件。lib文件是必须在编译期就连接到应用程序中的，而dll文件是运行期才会被调用的。 如果有dll文件，那么对应的lib文件一般是一些索引信息，具体的实现在dll文件中。如果只有lib文件，那么这个lib文件是静态编译出来的，索引和实现都在其中。静态编译的lib文件有好处：给用户安装时就不需要再挂动态库了。但也有缺点，就是导致应用程序比较大，而且失去了动态库的灵活性，在版本升级时，同时要发布新的应用程序才行。在动态库的情况下，有两个文件，而一个是引入库（.LIB）文件，一个是DLL文件，引入库文件包含被DLL导出的函数的名称和位置，DLL包含实际的函数和数据，应用程序使用LIB文件链接到所需要使用的DLL文件，库中的函数和数据并不复制到可执行文件中，因此在应用程序的可执行文件中，存放的不是被调用的函数代码，而是DLL中所要调用的函数的内存地址，这样当一个或多个应用程序运行是再把程序代码和被调用的函数代码链接起来，从而节省了内存资源。从上面的说明可以看出，DLL和.LIB文件必须随应用程序一起发行，否则应用程序将会产生错误。

静态库和共享库都是一个obj文件的集合 ，但静态链接后，执行程序中存在自己所需obj的一份拷贝，而动态链接后，执行程序仅仅是包含对共享库的一个引用。共享库相当于一个由多个obj文件组合而成的obj文件，在链接后其所有代码被加载，不管需要的还是不需要的。
似乎可以得出一个结论：
  静态链接后的程序比动态链接的所用存储空间大，因为执行程序中包含了库中代码拷贝；
  而动态链接的程序比静态链接的所用的运行空间大，因为它将不需要的代码也加载到运行空间。

针对上面的知识2 个问题：

1） DLL和.LIB文件必须随应用程序一起发行，否则应用程序将会产生错误。
我的答案：lib应该不需要吧。

2）如果是某个程序中调用了一个动态库（通过header文件，lib+dll来调用），则对动态库的某个函数的内容修改了，但接口不改，则调用此动态库的程序需重新编译连接吗？如果是通过loadlibary动态加载，需要重新编译连接吗？
我的答案：通过header+lib+dll调用的话需要重新编译连接，但是通过loadlibrary来使用的话，不需要重新编译连接。

欢迎大家讨论！

完！

在31年前(1979年)，一名刚获得博士学位的研究员，为了开发一个软件项目发明了一门新编程语言，该研究员名为Bjarne Stroustrup，该门语言则命名为——C with classes，四年后改称为C++。C++是一门通用编程语言，支持多种编程范式，包括过程式、面向对象(object-oriented programming, OP)、泛型(generic programming, GP)，后来为泛型而设计的模版，被发现及证明是图灵完备的，因此使C++亦可支持模版元编程范式(template metaprogramming, TMP)。C++继承了C的特色，既为高级语言，又含低级语言功能，可同时作为系统和应用编程语言。

C++广泛应用在不同领域，使用者以数百万计。根据近十年的调查，C++的流行程度约稳定排行第3位(于C/Java之后)。 C++经历长期的实践和演化，才成为今日的样貌。1998年，C++标准委员会排除万难，使C++成为ISO标准(俗称C++98)，当中含非常强大的标准模版库(standard template library, STL)。之后委员会在2005年提交了有关标准库的第一个技术报告(简称TR1)，并为下一个标准C++0x而努力。可惜C++0x并不能在200x年完成，各界希望新标准能于2011年内出台。

流行的C++编译器中，微软Visual C++ 2010已实现部分C++0x语法并加入TR1扩充库，而gcc对C++0x语法和库的支持比VC2010更多。

应否选择C++

哪些程序适宜使用C++?

C++并非万能丹，我按经验举出一些C++的适用时机。

• C++适合构造程序中需求较稳定的部分，需求变化较大的部分可使用脚本语言；
• 程序须尽量发挥硬件的最高性能，且性能瓶颈在于CPU和内存；
• 程序须频繁地与操作系统或硬件沟通；
• 程序必须使用C++框架/库，如大部分游戏引擎(如Unreal/Source)及中间件(如Havok/FMOD)，虽然有些C++库提供其他语言的绑定，但通常原生的API性能最好、最新；
• 项目中某个目标平台只提供C++编译器的支持。

按应用领域来说，C++适用于开发服务器软件、桌面应用、游戏、实时系统、高性能计算、嵌入式系统等。

使用C++还是C?

C++和C的设计哲学并不一样，两者取舍不同，所以不同的程序员和软件项目会有不同选择，难以一概而论。与C++相比，C具备编译速度快、容易学习、显式描述程序细节、较少更新标准(后两者也可同时视为缺点)等优点。在语言层面上，C++包含绝大部分C语言的功能(例外之一，C++没有C99的变长数组VLA)，且提供OOP和GP的特性。但其实用C也可实现OOP思想，亦可利用宏去实现某程度的GP，只不过C++的语法能较简洁、自动地实现OOP/GP。C++的RAII(resource acquisition is initialization，资源获取就是初始化)特性比较独特，C/C#/Java没有相应功能。回顾历史，Stroustrup开发的早期C++编译器Cpre/Cfront是把C++源代码翻译为C，再用C编译器编译的。由此可知，C++编写的程序，都能用等效的C程序代替，但C++在语言层面上提供了OOP/GP语法、更严格的类型检查系统、大量额外的语言特性(如异常、RTTI等)，并且C++标准库也较丰富。有时候C++的语法可使程序更简洁，如运算符重载、隐式转换。但另一方面，C语言的API通常比C++简洁，能较容易供其他语言程序调用。因此，一些C++库会提供C的API封装，同时也可供C程序调用。相反，有时候也会把C的API封装成C++形式，以支持RAII和其他C++库整合等。

为何C++性能可优于其他语言?

相对运行于虚拟机语言(如C#/Java)，C/C++直接以静态形式把源程序编译为目标平台的机器码。一般而言，C/C++程序在编译及链接时可进行的优化最丰富，启动时的速度最快，运行时的额外内存开销最少。而C/C++相对动态语言(如Python/Lua)也减少了运行时的动态类型检测。此外，C/C++的运行行为是确定的，且不会有额外行为(例如C#/Java必然会初始化变量)，也不会有如垃圾收集(GC)而造成的不确定性延迟，而且C/C++的数据结构在内存中的布局也是确定的。有时C++的一些功能会使程序性能优于C，当中以内联和模版最为突出，这两项功能使C++标准库的sort()通常比C标准库的qsort()快多倍(C可用宏或人手编码去解决此问题)。另一方面，C/C++能直接映射机器码，之间没有另一层中间语言，因此可以做底层优化，例如使用内部(intrinsic)函数和嵌入汇编语言。然而，许多C++的性能优点并非免费午餐，代价包括较长的编译链接时间和较易出错，因而增加开发时间和成本，这点稍后补充。

我进行了一个简单全局渲染性能测试(512x512像素，每像素10000个采样)，C++ 1小时36分、Java 3小时18分、Python约18天、Ruby约351天。评测方式和其他语言的结果详见博文。

C++常见问题

C++源代码跨平台吗?

C++有不错的跨平台能力，但由于直接映射硬件，因性能优化的关系，跨平台能力不及Java及多数脚本语言。然而，实践跨平台的C++软件还是可行的，但须注意以下问题：

• C++标准没有规定原始数据类型(如int)的大小，需要特定大小的类型时，可自订类型(如int32_t)，同时对任何类型使用sizeof()而不假设其大小；
• 字节序(byte order)按CPU有所不同，特别要注意二进制输入输出、reinterpret_cast法；
• 原始数据和结构类型的地址对齐有差异；
• 编译器提供的一些编译器或平台专用扩充指令；
• 避免作应用二进制接口(application binary interface, ABI)的假设，例如调用函数时参数的取值顺序在C/C++中没定义，在C++中也不可随便假设RTTI/虚表等实现方式。

总括而言，跨平台C++软件可在头文件中用宏检测编译器和平台，再用宏、typedef、自定平台相关实现等方法去实践跨平台，C++标准不会提供这类帮助。

C++程序容易崩溃?

和许多语言相比，C/C++提供不安全的功能以最优化性能，有可能造成崩溃。但要注意，很多运行时错误，如向空指针/引用解引用、数组越界、堆栈溢出等，其他语言也会报错或抛出异常，这些都是程序问题，而不是语言本身的问题。有些意见认为，出现这类运行时错误，应该尽量写入日志并立即崩溃，不该让程序继续运行，以免造成更大的影响(例如程序继续把内存中错误的数据覆写文件)。若要容错，可按业务把程序分割为多进程，像Chrome或使用fork()的形式。然而，C++有许多机制可以减少错误，例如以string代替C字符串；以vector或array(TR1)代替原始数组(有些实现可在调试模式检测越界)；使用智能指针也能减少一些原始指针的问题。另外，我最常遇到的Bug，就是没有初始化成员变量，有时会导致崩溃，而且调试版和发行版的行为可能不同。

C++要手动做内存管理?

C++同时提供在堆栈上的自动局部变量，以及从自由存储(free store)分配的对象。对于后者，程序员需手动释放，或使用不同的容器和智能指针。 C++程序员经常进一步优化内存，自定义内存分配策略以提升效能，例如使用对象池、自定义的单向/双向堆栈区等。虽然C++0x还没加入GC功能，但也可以自行编写或使用现成库。此外，C/C++也可以直接使用操作系统提供的内存相关功能，例如内存映射文件、共享内存等。

使用C++常要重造轮子?

我曾参与的C++项目，都会重造不少标准库已提供的功能，此情况在其他语言中较少出现。我试图分析个中原因。首先，C++标准库相对很多语言来说是贫乏的，各开发者便会重复地制造自订库。从另一个角度看，C++标准库是用C++编写的(很多其他语言不用自身而是用C/C++去编写库)，在能力和性能上，自订库和标准库并无本质差别；另外，标准库为通用而设，对不同平台及多种使用需求作取舍，性能上有所影响，例如EA公司就曾发表自制的EASTL规格，描述游戏开发方面对STL的性能及功能需求的特点；此外，多个C++库一起使用，经常会因规范不同而引起冲突，又或功能重叠，所以项目可能须自行开发，或引入其他库的概念或实现(如Boost/TR1/Loki)，改写以符合项目规范。

C++编译速度很慢?

错，是非常慢。我认为C++可能是实用程序语言中编译速度最慢的。此问题涉及C++沿用C的编译链接方式，又加入了复杂的类/泛型声明和内联机制，使编译时间倍增。在C++对编译方法改革之前(如module提案)，可使用以下技巧改善：第一，使用pimpl手法，因性能损耗应用于调用次数不多的类；第二，仅包含必要头文件，并尽量使用及提供前置声明版本的头文件(如iosfwd)；第三采用基于接口的设计，但须注意虚函数调用成本；第四，采用unity build，即把多个cpp文件结合在一个编译单元进行编译；第五，采用分布式生成系统如IncrediBuild。

C++缺乏什么功能?

虽然C++已经非常复杂，但仍缺少很多常见功能。 C++0x作出了不少改善，例如语言方面加入Lambda函数、闭包、类型推导声明等，而库方面则加入正则表达式、采用哈希表的unordered_set/unordered_map、引用计数智能指针shared_ptr/weak_ptr等。但最值得留意的是C++0x引入多线程的语法和库功能，这是C++演进的一大步。然而，模组、GC、反射机制等功能虽有提案，却未加进C++0x。

C++使用建议

为应用挑选特性集

我同意Stroustrup关于使用C++各种技术的回应：“你可以做，不意味着你必须这么做。(Just because you can do it, doesn't mean that you have to.)” C++充满丰富的特性，但同时带来不同问题，例如过分复杂、编译及运行性能的损耗。一般可考虑是否使用多重继承、异常、RTTI，并调节使用模版及模版元编程的程度。使用过分复杂的设计和功能，可能会令部分团队成员更难理解和维护。

为团队建立编程规范

C++的编码自由度很高，容易编写风格迥异的代码，C++本身也没有定义一些标准规范。而且，C++的源文件物理构成，较许多语言复杂。因此，除了决定特性集，每个团队应建立一套编程规范，包括源文件格式(可使用文件模版)、花括号风格。

尽量使用C++风格而非C风格

由于C++有对C兼容的包袱，一些功能可以使用C风格实现，但最好使用C++提供的新功能。最基本的是尽量以具名常量、内联函数和泛型取代宏，只把宏用在条件式编译及特殊情况。旧式的C要求局部变量声明在作用域开端，C++则无此限制，应把变量声明尽量置于邻近其使用的地方，for()的循环变量声明可置于for的括号内。 C++中能加强类型安全的功能应尽量使用，例如避免“万能”指针void *，而使用个别或泛型类型；用bool而非int表示布尔值；选用4种C++ cast关键字代替简单的强制转换。

结合其他语言

如前文所述，C++并非适合所有应用情境，有时可以混合其他语言使用，包括用C++扩展其他语言，或在C++程序中嵌入脚本语言引擎。对于后者，除了使用各种脚本语言的专门API，还可使用Boost或SWIG作整合。

C++学习建议

C++缺点之一，是相对许多语言复杂，而且难学难精。许多人说学习C语言只需一本K&R《C程序设计语言》即可，但C++书籍却是多不胜数。我是从C进入C++，皆是靠阅读自学。在此分享一点学习心得。个人认为，学习C++可分为4个层次：

• 第一层次，C++基础：挑选一本入门书籍，如《C++ Primer》、《C++大学教程》、或Stroustrup撰写的经典《C++程序设计语言》或他一年半前的新作《C++程序设计原理与实践》，而一般C++课程也止于此，另外《C++ 标准程序库》及《The C++ Standard Library Extensions》可供参考；
• 第二层次，正确高效地使用C++：此层次开始必须自修，阅读过《(More)Effective C++》、《(More)Exceptional C++》、《Effective STL》及《C++编程规范》等，才适宜踏入专业C++开发之路；
• 第三层次，深入了解C++：关于全局问题可读《深入探索C++对象模型》、《Imperfect C++》、《C++沉思录》、《STL源码剖析》，要挑战智商，可看关于模版及模版元编程的书籍如《C++ Templates》、《C++设计新思维》、《C++模版元编程》；
• 第四层次，研究C++：阅读《C++语言的设计和演化》、《编程的本质》(含STL设计背后的数学根基)、C++标准文件《ISO/IEC 14882:2003》、C++标准委员会的提案书和报告书、关于C++的学术文献。

由于我主要是应用C++，大约只停留于第二、三个层次。然而，C++只是软件开发的一环而已，单凭语言并不能应付业务和工程上的问题。建议读者不要强求几年内“彻底学会C++的知识”，到达第二层左右便从工作实战中汲取经验，有兴趣才慢慢继续学习更高层次的知识。虽然学习C++有难度，但也是相当有趣且有满足感的。

数十年来，C++虽有起伏，但她依靠其使用者而不断得到顽强的生命力，相信在我退休之前都不会与她分离，也希望更进一步了解她，与她走进未来。

本文原于《程序员》2010年8月刊揭载。

QUOTE: 我们对很多开发开源项目的人心存感激，我们承诺会沿着前人的路继续前行。 我们借鉴了一些源自 Apple WebKit 和 Mozilla Firefox 的技术，怀着同样开源的精神，谷歌浏览器所有的代码全部开源。我们希望能与整个业界合作从而促进互联网的健康发展。

　　目前 Google Chrome 源码已经公布了，有兴趣的软件开发者、程序员可以从 chromium.org 服务器使用 SVN checkout Google Chrome Source Code，自定义自己的浏览器。

Google Chrome 源码下载地址 (Google Chrome Source Code Download)

　　地址： http://www.xiaohui.com/dev/vccool/internet/google-chrome-source-code-download.htm

　　1. Google Chrome 源码 SVN 地址：http://src.chromium.org/svn。包含有 Chrome、Gears、Webkit、GCC 等源码以及编译依赖工具。Chrome 浏览器项目的源码，位于目录 http://src.chromium.org/svn/trunk/src/chrome/

　　2. Google Chrome 源码 Web 浏览地址：http://src.chromium.org/viewvc/

　　3. Google Chrome 所使用的 JavaScript V8 的源码下载地址：http://code.google.com/p/v8/

Google Chrome 源码下载相关资源

• 站内文章：Google Chrome 的内核引擎 WebKit 介绍 - WebKit Open Source Project
• 站内文章：Google 浏览器 Google Chrome 最新试用手记 - 第一时间试用 Google Chrome 的感受
• 外部连接：WebKit.org - WebKit Open Source Project
• 外部连接：在 Linux 上使用 WebKit 引擎浏览器 - 来自 Nicky's Blog 的文章
• 外部链接：Google 官方 Blog 的文章 - 谷歌浏览器（Google Chrome）, Chromium 以及竞争
• 外部链接：Google 官方 Blog 的文章 - 浏览器的新视角
• 外部链接：Google Chrome Themes - 下载 Google Chrome Themes

一 线程

1）如果你正在编写C/C++代码，决不应该调用CreateThread。相反，应该使用VisualC++运行期库函数_beginthreadex，退出也应该使用_endthreadex。如果不使用Microsoft的VisualC++编译器，你的编译器供应商有它自己的CreateThred替代函数。不管这个替代函数是什么，你都必须使用。

2）因为_beginthreadex和_endthreadex是CRT线程函数，所以必须注意编译选项runtimelibaray的选择，使用MT或MTD。

3) _beginthreadex函数的参数列表与CreateThread函数的参数列表是相同的，但是参数名和类型并不完全相同。这是因为Microsoft的C/C++运行期库的开发小组认为，C/C++运行期函数不应该对Windows数据类型有任何依赖。_beginthreadex函数也像CreateThread那样，返回新创建的线程的句柄。

4）下面是关于_beginthreadex的一些要点：

•每个线程均获得由C/C++运行期库的堆栈分配的自己的tiddata内存结构。（tiddata结构位于Mtdll.h文件中的VisualC++源代码中）。

•传递给_beginthreadex的线程函数的地址保存在tiddata内存块中。传递给该函数的参数也保存在该数据块中。

•_beginthreadex确实从内部调用CreateThread，因为这是操作系统了解如何创建新线程的唯一方法。

•当调用CreatetThread时，它被告知通过调用_threadstartex而不是pfnStartAddr来启动执行新线程。还有，传递给线程函数的参数是tiddata结构而不是pvParam的地址。

•如果一切顺利，就会像CreateThread那样返回线程句柄。如果任何操作失败了，便返回NULL。

5) _endthreadex的一些要点：

•C运行期库的_getptd函数内部调用操作系统的TlsGetValue函数，该函数负责检索调用线程的tiddata内存块的地址。

•然后该数据块被释放，而操作系统的ExitThread函数被调用，以便真正撤消该线程。当然，退出代码要正确地设置和传递。

6) 虽然也提供了简化版的的_beginthread和_endthread，但是可控制性太差，所以一般不使用。

6）线程handle因为是内核对象，所以需要在最后close handle。

7）C++主线程的终止，同时也会终止所有主线程创建的子线程，不管子线程有没有执行完毕。

8）如果某线程挂起，然后有调用WaitForSingleObject等待该线程，就会导致死锁。

二 线程同步之Critical Sections

1） 因为Critical Sections不是内核对象，所以只能用来同一进程内线程间的同步，不能用来多个不同进程间的线程的同步。

2） 如果在Critical Sections中间突然程序crash或是exit而没有调用LeaveCriticalSection，则结果是该线程所对应的内核不能被释放，该线程成为死线程。

3） 要比其他的内核对象的速度要快。

4）很好的封装：

class CritSect
{
public:
    friend class Lock;
    CritSect() { InitializeCriticalSection(&_critSection); }
    ~CritSect() { DeleteCriticalSection(&_critSection); }
private:
    void Acquire(){EnterCriticalSection(&_critSection);}
    void Release(){LeaveCriticalSection(&_critSection);}

    CRITICAL_SECTION _critSection;
};

class Lock
{
public:
     Lock(CritSect& critSect):_critSect(critSect) {    _critSect.Acquire(); }
     ~Lock(){_critSect.Release();}
private:
    CritSect& _critSect;
};
调用：CritSect sect;Lock lock(sect);

三 线程同步之Mutex
   
1）互斥对象（mutex）内核对象能够确保线程拥有对单个资源的互斥访问权。实际上互斥对象是因此而得名的。互斥对象包含一个使用数量，一个线程ID和一个递归计数器。
 2） 互斥对象的行为特性与关键代码段相同，但是互斥对象属于内核对象，而关键代码段则属于用户方式对象。这意味着互斥对象的运行速度比关键代码段要慢。但是这也意味着不同进程中的多个线程能够访问单个互斥对象，并且这意味着线程在等待访问资源时可以设定一个超时值。

 3） ID用于标识系统中的哪个线程当前拥有互斥对象，递归计数器用于指明该线程拥有互斥对象的次数。

 4） 互斥对象有许多用途，属于最常用的内核对象之一。通常来说，它们用于保护由多个线程访问的内存块。如果多个线程要同时访问内存块，内存块中的数据就可能遭到破坏。互斥对象能够保证访问内存块的任何线程拥有对该内存块的独占访问权，这样就能够保证数据的完整性。

5）互斥对象的使用规则如下：

• 如果线程ID是0（这是个无效ID），互斥对象不被任何线程所拥有，并且发出该互斥对象的通知信号。

• 如果ID是个非0数字，那么一个线程就拥有互斥对象，并且不发出该互斥对象的通知信号。

• 与所有其他内核对象不同， 互斥对象在操作系统中拥有特殊的代码，允许它们违反正常的规则。

四 线程同步之Event

1）在所有的内核对象中，事件内核对象是个最基本的对象。它们包含一个使用计数（与所有内核对象一样），一个用于指明该事件是个自动重置的事件还是一个人工重置的事件的布尔值，另一个用于指明该事件处于已通知状态还是未通知状态的布尔值。

2）事件能够通知一个操作已经完成。有两种不同类型的事件对象。一种是人工重置的事件，另一种是自动重置的事件。当人工重置的事件得到通知时，等待该事件的所有线程均变为可调度线程。当一个自动重置的事件得到通知时，等待该事件的线程中只有一个线程变为可调度线程。

3）当一个线程执行初始化操作，然后通知另一个线程执行剩余的操作时，事件使用得最多。事件初始化为未通知状态，然后，当该线程完成它的初始化操作后，它就将事件设置为已通知状态。这时，一直在等待该事件的另一个线程发现该事件已经得到通知，因此它就变成可调度线程。

 4）Microsoft为自动重置的事件定义了应该成功等待的副作用规则，即当线程成功地等待到该对象时，自动重置的事件就会自动重置到未通知状态。这就是自动重置的事件如何获得它们的名字的方法。通常没有必要为自动重置的事件调用ResetEvent函数，因为系统会自动对事件进行重置。但是，Microsoft没有为人工重置的事件定义成功等待的副作用，所以需要调用ResetEvent()。

五 线程同步之信号量（Semaphore）

信号量（Semaphore）内核对象对线程的同步方式与前面几种方法不同，它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用 CreateSemaphore（）创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过 ReleaseSemaphore（）函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。

使用信号量内核对象进行线程同步主要会用到CreateSemaphore（）、OpenSemaphore（）、ReleaseSemaphore（）、 WaitForSingleObject（）和WaitForMultipleObjects（）等函数。

六 线程同步之其他

1）线程局部存储 （TLS），同一进程中的所有线程共享相同的虚拟地址空间。不同的线程中的局部变量有不同的副本，但是static和globl变量是同一进程中的所有线程共享的。使用TLS技术可以为static和globl的变量，根据当前进程的线程数量创建一个array，每个线程可以通过array的index来访问对应的变量，这样也就保证了static和global的变量为每一个线程都创建不同的副本。

2）互锁函数的家族十分的庞大，例如InterlockedExchangeAdd（）。。。，使用互锁函数的优点是：他的速度要比其他的CriticalSection,Mutex,Event,Semaphore快很多。

3）等待函数，例如WaitForSingleObject 函数用来检测 hHandle 事件的信号状态，当函数的执行时间超过 dwMilliseconds 就返回，但如果参数 dwMilliseconds 为 INFINITE 时函数将直到相应时间事件变成有信号状态才返回，否则就一直等待下去，直到 WaitForSingleObject 有返回直才执行后面的代码。

六 《Windows核心编程（英文版·第5版）》
最好的windows多线程编程参考，更多更详细请看原书。

一、绪论

当微软推出VS.NET7实现了可扩展的托管C++后，C++程序员们反映不一。尽管大部分的程序员对于能够继续使用C++感到很欣慰，但几乎所有的人对于托管C++提供的晦涩语法感到很痛苦。微软明显从反馈中感觉到托管C++不是那么成功。

2003年10月6日，ECMA（欧洲计算机制造商协会）宣布成立专家组，负责结合ISO标准C++与通用语言，开发一个可扩展语言的标准，这个新的可扩展语言被称为C++/CLI标准。这个标准将被VS.NET2005的C++编译器支持。

二、老语法存在的问题

1、晦涩繁琐的语法和文法--这两个"双重底线"问题加重了阅读的负担。

2、二流的CLI支持--相对与C#与VB.NET，MC++使用不方便的工作区来提供CLI支持，例如，它没有一个一一对应的结构来列举.NET的集合。

3、C++与.NET粗陋地结合--对于CLI类型，你不能使用C++的特色，例如模板；同样，对于C++类型，你不能使用CLI的特色，例如碎片帐集。

4、令人混淆的指针--非托管的C++的指针及托管的引用指针都使用*语法，这非常令人混淆，因为-gc指针与托管指针在本质和行为上完全不同。

5、MFC编译器不能产生可校验的代码。

三、C++/CLI给我们提供了什么？

1、优雅流畅的语法和文法--C++/CLI为C++开发人员书写托管代码提供了一种非常自然的感觉，并且它提供了非托管代码到托管代码的平滑过度。以前所谓的"双重底线"问题现在已经荡然无存。

2、一流的CLI支持--CLI特色，例如属性、碎片集合和属类得到了直接支持，此外，C++/CLI还准许将这些特色用于本地非托管的类。

3、一流的C++类支持--C++特色，例如模板和析构函数对于拖管和非拖管类继续有效。实际上，C++/CLI是你可以"表面上"在栈或C++本地堆上声明一个.NET类型唯一的.NET语言。

4、在.NET与C++之间的沟壑上架起了一座桥梁--C++开发人员在抨击BCL时不再象离开水的鱼。

5、C++/CLI编译器产生的可执行文件完全是可校验的。

四、"Hello World"小程序

using namespace System; void _tmain() { Console::WriteLine("Hello World"); }

上述代码除了不需要引用mscorlib.dll库外，与老的语法没有太大的区别，因为无论你什么时候使用/clr进行编辑，编译器都可以暗中进行引用（现在默认的是/clr:newSyntax）。

五、句柄

与老的语法主要的混淆是我们习惯于使用*符号来声明拖管引用或非拖管指针，在C++/CLI里微软引入了句柄的概念。

void _tmain() { //The ^ punctuator represents a handle String^ str = "Hello World"; Console::WriteLine(str); }

^符号代表一个托管对象（声明时看上去象个帽子），按照CLI的规定，句柄代表一个拖管对象的引用。句柄在CLI中是新的语法，相当于C++中的-gc指针。句柄与指针不再混淆，在本质上两者完全不同。

六、句柄与指针是怎样区分开来的？

1、指针声明时使用*符号，而句柄使用^符号。

2、句柄是针对拖管堆上对象的拖管引用，而指针仅仅指向内存中的一个地址。

3、指针很稳定，GC循环不会影响到它；句柄在基于GC或内存紧张的情况下，可以指向不同的内存位置。

4、对于指针，程序开发人员必须"显式"地删除，否则会面临泄露的危险，而对于句柄，是否进行显式删除则完全根据程序人员的爱好了。

5、句柄一定要指向一个具体的类型，即所谓的类型安全性，而指针明显不是这样，你决不可以将一个句柄指向Void^类型。

6、正如new操作符返回一个指针一样，gcnew返回一个句柄。

七、CLR对象示例

void _tmain() { String^ str = gcnew String("Hello World"); Object^ o1 = gcnew Object(); Console::WriteLine(str); }

关键字gcnew用来实例化一个CLI对象，而且它返回一个指向在CLR堆上的对象的句柄，gcnew的优点在于它可以方便的让我们区分拖管和非拖管的实例对象。

大部分情况下，gcnew关键字和^操作符提供了你用来进行BCL的一切手段，但是很明显你需要创建和声明属于自己的拖管类和接口。

八、声明类型

CLR类型有一个形容词前缀用来说明类型的种类，下面是C++/CLI中的类型声明示例：

1、 CLR types o Reference types § ref class RefClass; § ref struct RefClass; 2、 Value types § value class ValClass; § value struct ValClass; o Interfaces § interface class IType; § interface struct IType; o Enumerations § enum class Color; § enum struct Color; 3、 Native types o class Native; o struct Native; 示例： using namespace System; interface class IDog { void Bark(); }; ref class Dog : IDog { public: void Bark() { Console::WriteLine("Bow wow wow"); } }; void _tmain() { Dog^ d = gcnew Dog(); d->Bark(); }

上述程序中的代码与老的C++语言相比看上去非常简洁，在以往的C++代码中，至少要用到-gc和-interface这两个关键词。

九、装箱/拆箱操作

在C++/CLI中，加箱是隐含的，而且类型是安全的，一个二进制的拷贝被执行并在CLR堆上形成一个对象，去箱是显式的，仅仅需要使用reinterpret_cast操作符来解除引用。

void _tmain() { int z = 44; Object^ o = z; //implicit boxing int y = *reinterpret_cast<int^>(o); //unboxing Console::WriteLine(" ",o,z,y); z = 66; Console::WriteLine(" ",o,z,y); } // 输出结果如下： // 44 44 44 // 44 66 44

在上述代码中，"o"对象是一个加箱的拷贝，从第二个语句Console::WriteLine.的输出可以很明显地看到，它并没有涉及到int类型的整数值。

当你对一种数值类型进行加箱操作时，返回的对象记住了最初的数值类型。

void _tmain() { int z = 44; float f = 33.567; Object^ o1 = z; Object^ o2 = f; Console::WriteLine(o1->GetType()); Console::WriteLine(o2->GetType()); } // Output // System.Int32 // System.Single

因此不能对不同类型的对象进行去箱操作。

void _tmain() { int z = 44; float f = 33.567; Object^ o1 = z; Object^ o2 = f; int y = *reinterpret_cast<int^>(o2);//System.InvalidCastException float g = *reinterpret_cast<float^>(o1);//System.InvalidCastException }

如果你非尝试这么做，那么你将得到一个System.InvalidCastException。让我们来探讨一下完美的类型安全性，如果你要看内部代码，你将看到微软的内部箱在实际中的运用。例如：

void Box2() { float y=45; Object^ o1 = y; }

编译后的代码是：

.maxstack 1 .locals (float32 V_0, object V_1) ldnull stloc.1 ldc.r4 45. stloc.0 ldloc.0 box [mscorlib]System.Single stloc.1 ret

根据微软的内部文档，箱操作将未加工的类型转换为一个具体类型的实例，这项工作的完成通过创建一个新的对象并将数据拷贝到这个新分配的对象。

十、写在后面的话

为什么很多人已经可以使用C、C++、.NET来开发程序但还在积极学习C++/CLI呢，我想有四个方面的原因：

1、从编译器直到内层都还在支持C++代码；

2、C++/CLI对于其他标准来说无意是具有毁灭性地；

3、与生俱来的内部支持胜过所有其他CLI语言

4、所有在MFC中出现的下划线都已不再存在。

C++/CLI：第一流的CLI语言
2005-08-25 11:25 作者： 朱先忠编译 出处： 天极网 责任编辑：方舟

1. 简介

　　本文并不是为了奉承C++/CLI的辉煌，也不是为了贬低其它如C#或者VB.NET等语言，相反，这只是一个非官方的、以一个喜欢这种语言的非微软雇员身份来论证C++/CLI有它的自己的唯一的角色，可作为第一流的.NET编程语言。

　　一个不断在新闻组和技术论坛上出现的问题是，当象C#和VB.NET这样的语言更适合于这种用途时，为什么要使用C++来开发.NET应用软件。通常这样一些问题后面的评论说是，C++语法是怎样的复杂和令人费解，C++现在是怎样一种过时的语言，还有什么VS.NET设计者已不再像支持C#和VB.NET一样继续支持C++。其中一些猜疑是完全荒谬的，但有些说法部分正确。希望本文有助于澄清所有这些围绕C++/CLI语言及其在VS.NET语言层次中的地位的疑惑，神秘和不信任。请记住，本作者既不为微软工作也没有从微软那里取得报酬，只是想从技术上对C++/CLI作一评判。

　　2. 快速简洁的本机interop

　　除了P/Invoke机制可用在另外的象C#或VB.NET这样的语言外，C++提供了一种独有的interop机制，称作C++ interop。C++ interop比P/Invoke直观得多，因为你只是简单地#include需要的头文件，并与需要的库进行链接就能象在本机C++中一样调用任何函数。另外，它比P/Invoke速度快--这是很容易能证明的。现在，可争辩的是在实际应用软件的开发中，经由C++ interop获得的性能好处与花在用户接口交互、数据库存取、网络数据转储、复杂数学算法等方面的时间相比可以被忽略，但是事实是在有些情况下，甚至通过每次interop调用节省的几个纳秒也能给全局应用程序性能/响应造成巨大影响，这是绝对不能被忽视的。下面有两部分代码片断(一个是使用P/Invoke机制的C#程序，一个是使用C++ Interop机制的C++程序)，我分别记录了其各自代码重复执行消耗的时间(毫秒)。不管你如何解释这些数据，不管这会对你的应用程序产生什么影响，全是你的事。我仅打算事实性地指出，C++代码的执行速度要比C#(其中使用了较多的本机interop调用)快。

　　1) C#程序(使用P/Invoke)

[SuppressUnmanagedCodeSecurity] [DllImport("kernel32.dll")] static extern uint GetTickCount(); [SuppressUnmanagedCodeSecurity] [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)] static extern uint GetWindowsDirectory( [Out] StringBuilder lpBuffer, uint uSize); static void Test(int x) { StringBuilder sb = new StringBuilder(512); for (int i = 0; i < x; i++) GetWindowsDirectory(sb, 511); } static void DoTest(int x) { uint init = GetTickCount(); Test(x); uint tot = GetTickCount() - init; Console.WriteLine("Took {0} milli-seconds for {1} iterations",tot, x); } static void Main(string[] args) { DoTest(50000);DoTest(500000);DoTest(1000000);DoTest(5000000); Console.ReadKey(true); }

　　2) C++程序(使用C++ Interop)

void Test(int x) { TCHAR buff[512]; for(int i=0; i<x; i++) GetWindowsDirectory(buff, 511); } void DoTest(int x) { DWORD init = GetTickCount(); Test(x); DWORD tot = GetTickCount() - init; Console::WriteLine("Took {0} milli-seconds for {1} iterations",tot, x); } int main(array<System::String ^> ^args) { DoTest(50000);DoTest(500000);DoTest(1000000);DoTest(5000000); Console::ReadKey(true); return 0; }

　　3) 速度比较

重复次数	C# 程序	C++程序
50,000	61	10
500,000	600	70
1,000,000	1162	140
5,000,000	6369	721

　　
　　其性能差别真是令人惊愕！这的确是说明为什么要使用C++/CLI的一个好理由，如果你在使用本机interop进行开发，那么性能！完全由于性能，我就将被迫借助本机interop来实现并非基于web的.NET应用程序。当然，为什么我想要使用.NET来开发需要大量本机interop技术的应用程序完全是另外一个问题。

　　如果你仍怀疑这种性能优势，有另外的理由来说明你为什么不得不使用C++/CLI而不是C#或VB.NET——源码膨胀！下面是一个C++函数的例子，它使用了IP帮助者API来枚举一台机器上的网络适配器并且列出与每个适配器相联系的所有IP地址。

　　4) 枚举n/w适配器的C++代码

void ShowAdapInfo() { PIP_ADAPTER_INFO pAdapterInfo = NULL; ULONG OutBufLen = 0; //得到需要的缓冲区大小 if(GetAdaptersInfo(NULL,&OutBufLen)==ERROR_BUFFER_OVERFLOW) { int divisor = sizeof IP_ADAPTER_INFO; #if _MSC_VER >= 1400 if( sizeof time_t == 8 ) divisor -= 8; #endif pAdapterInfo = new IP_ADAPTER_INFO[OutBufLen/divisor]; //取得适配器信息 if( GetAdaptersInfo(pAdapterInfo, &OutBufLen) != ERROR_SUCCESS ) {//调用失败 } else { int index = 0; while(pAdapterInfo) { Console::WriteLine(gcnew String(pAdapterInfo->Description)); Console::WriteLine("IP Address list : "); PIP_ADDR_STRING pIpStr = &pAdapterInfo->IpAddressList; while(pIpStr) { Console::WriteLine(gcnew tring(pIpStr->IpAddress.String)); pIpStr = pIpStr->Next; } pAdapterInfo = pAdapterInfo->Next; Console::WriteLine(); } } delete[] pAdapterInfo; } }

　　现在让我们看一个使用P/Invoke的C#版本。

　　5) 使用P/Invoke技术的C#版本

const int MAX_ADAPTER_NAME_LENGTH = 256; const int MAX_ADAPTER_DESCRIPTION_LENGTH = 128; const int MAX_ADAPTER_ADDRESS_LENGTH = 8; const int ERROR_BUFFER_OVERFLOW = 111; const int ERROR_SUCCESS = 0; [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] public struct IP_ADDRESS_STRING { [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)] public string Address; } [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] public struct IP_ADDR_STRING { public IntPtr Next; public IP_ADDRESS_STRING IpAddress; public IP_ADDRESS_STRING Mask; public Int32 Context; } [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] public struct IP_ADAPTER_INFO { public IntPtr Next; public Int32 ComboIndex; [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_ADAPTER_NAME_LENGTH + 4)] public string AdapterName; [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAX_ADAPTER_DESCRIPTION_LENGTH + 4)] public string AdapterDescription; public UInt32 AddressLength; [MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_ADAPTER_ADDRESS_LENGTH)] public byte[] Address; public Int32 Index; public UInt32 Type; public UInt32 DhcpEnabled; public IntPtr CurrentIpAddress; public IP_ADDR_STRING IpAddressList; public IP_ADDR_STRING GatewayList; public IP_ADDR_STRING DhcpServer; public bool HaveWins; public IP_ADDR_STRING PrimaryWinsServer; public IP_ADDR_STRING SecondaryWinsServer; public Int32 LeaseObtained; public Int32 LeaseExpires; } [DllImport("iphlpapi.dll", CharSet = CharSet.Ansi)] public static extern int GetAdaptersInfo(IntPtr pAdapterInfo, ref int pBufOutLen); static void ShowAdapInfo() { int OutBufLen = 0; //得到需要的缓冲区大小 if( GetAdaptersInfo(IntPtr.Zero, ref OutBufLen) == ERROR_BUFFER_OVERFLOW ) { IntPtr pAdapterInfo = Marshal.AllocHGlobal(OutBufLen); //取得适配器信息 if( GetAdaptersInfo(pAdapterInfo, ref OutBufLen) != ERROR_SUCCESS ) { //调用失败了 } else{ while(pAdapterInfo != IntPtr.Zero) { IP_ADAPTER_INFO adapinfo = (IP_ADAPTER_INFO)Marshal.PtrToStructure( pAdapterInfo, typeof(IP_ADAPTER_INFO)); Console.WriteLine(adapinfo.AdapterDescription); Console.WriteLine("IP Address list : "); IP_ADDR_STRING pIpStr = adapinfo.IpAddressList; while (true){ Console.WriteLine(pIpStr.IpAddress.Address); IntPtr pNext = pIpStr.Next; if (pNext == IntPtr.Zero) break; pIpStr = (IP_ADDR_STRING)Marshal.PtrToStructure( pNext, typeof(IP_ADDR_STRING)); } pAdapterInfo = adapinfo.Next; Console.WriteLine(); } } Marshal.FreeHGlobal(pAdapterInfo); } }

3. 栈语义和确定性的析构

　　C++经由栈语义模仿给了我们确定性的析构。简言之，栈语义是Dispose模式的良好的语法替代品。但是它在语义上比C# using块语法更直观些。请看下列的C#和C++代码段（都做一样的事情-连接两个文件的内容并把它写到第三个文件中）。

　　1) C#代码--使用块语义

public static void ConcatFilestoFile(String file1, String file2, String outfile) { String str; try{ using (StreamReader tr1 = new StreamReader(file1)) { using (StreamReader tr2 = new StreamReader(file2)) { using (StreamWriter sw = new StreamWriter(outfile)) { while ((str = tr1.ReadLine()) != null) sw.WriteLine(str); while ((str = tr2.ReadLine()) != null) sw.WriteLine(str); } } } } catch (Exception e) { Console.WriteLine(e.Message); } }

　　2) C++代码--栈语义

static void ConcatFilestoFile(String^ file1, String^ file2, String^ outfile) { String^ str; try{ StreamReader tr1(file1); StreamReader tr2(file2); StreamWriter sw(outfile); while(str = tr1.ReadLine()) sw.WriteLine(str); while(str = tr2.ReadLine()) sw.WriteLine(str); } catch(Exception^ e) { Console::WriteLine(e->Message); } }

　　C#代码与相等的C++ 代码相比不仅免不了冗长，而且using块语法让程序员自己明确地指定他想在哪儿调用Dispose（using块的结束处），而使用C++/CLI的栈语义，只需让编译器使用常规的范围规则来处理它即可。事实上，这使得在C#中修改代码比在C++中更乏味-作为一实例，让我们修改这些代码以便即使仅存在一个输入文件也能创建输出文件。请看下面修改后的C#和C++代码。

　　3) 修改后的C#代码

public static void ConcatFilestoFile(String file1, String file2, String outfile) { String str; try{ using (StreamWriter sw = new StreamWriter(outfile)) { try{ using (StreamReader tr1 = new StreamReader(file1)) { while ((str = tr1.ReadLine()) != null) sw.WriteLine(str); } } catch (Exception) { } using (StreamReader tr2 = new StreamReader(file2)) { while ((str = tr2.ReadLine()) != null) sw.WriteLine(str); } } } catch (Exception e){ } }

　　把针对StreamWriter的using块放到顶层需要重新调整using块结构--这在上面情况下显然不是个大问题，但是对于实际开发中的修改，这可能是相当模糊的且易导致逻辑错误的。

　　4) 修改后的C++代码

static void ConcatFilestoFile(String^ file1, String^ file2, String^ outfile) { String^ str; try{ StreamWriter sw(outfile); try{ StreamReader tr1(file1); while(str = tr1.ReadLine()) sw.WriteLine(str); } catch(Exception^){} StreamReader tr2(file2); while(str = tr2.ReadLine()) sw.WriteLine(str); } catch(Exception^){} }

　　这样不是比在C#中的做更容易些吗？我恰好把StreamWriter声明移到了顶部并增加了一个额外的try块，就这些。甚至对于象在我的示例代码片断中的琐碎事情，如果所涉及的复杂性在C++中大大减少，那么，当你工作于更大的工程时你能想象使用栈语义对你的编码效率千万的影响。

　　还不确信？好，让我们看一下成员对象和它们的析构吧。Imagine CLI GC类R1和R2，二者都实现了Idisposable接口且都有函数F()，还有一个CLI GC类R，它有R1和R2成员和一个函数F()-它内部地调用R1和R2上的F()成员函数。让我们先看C#实现。

　　5) 一个disposable类继承层次的C#实现

class R1 : IDisposable{ public void Dispose() { } public void F() { } } class R2 : IDisposable{ public void Dispose() { } public void F() { } } class R : IDisposable{ R1 m_r1 = new R1(); R2 m_r2 = new R2(); public void Dispose() { m_r1.Dispose(); m_r2.Dispose(); } public void F() { m_r1.F(); m_r2.F(); } public static void CallR() { using(R r = new R()) {r.F();} } }

　　这里有几件事情要做：必须为每个disposable 类手工实现IDisposable接口，对于具有成员R1和R2的类R，Dispose方法也需要调用成员类上的Dispose。现在让我们分析上面几个类的C++实现。

　　6) 等价的C++实现

ref class R1 { public: ~R1(){} void F(){} }; ref class R2 { public: ~R2(){} void F(){} }; ref class R { R1 m_r1; R2 m_r2; public: ~R(){} void F() { m_r1.F(); m_r2.F(); } static void CallR() { R r; r.F(); } };

　　注意，这里不再有手工的Idisposable接口实现(我们的类中仅建立了析构器)而且最好的部分--类R的析构器(Dispose方法)并没有在该类可能含有的可释放的成员上调用Dispose-它没有必要这样做，编译器自动为之生成所有的代码！

4. 混合类型

　　我们知道，C++支持本机类型-总是如此；C++支持CLI类型-本文正是特别强调这一点；它还支持混合类型-具有CLI成员的本机类型和具有本机成员的CLI类型！请尽管考虑所有你能的可能需求。

　　注意，谈到Whidbey，混合类型实现还不完整；就我从Brandon，Herb和Ronald发表的材料的理解得知，存在这种相当酷的类型--统一模型，它将在Orcas中实现--你能够在本机C++堆上new/delete CLI类型，而且也能够在CLI堆上gcnew/delete本机类型。但既然这是Whidbey以后的东西，本文不讨论统一模型。

　　在我谈论你何时使用混合类型以前，我想向你说明什么是混合类型。如果你理解混合类型，请跳过下面几段。这里引用Brandon Bray的说法："一种混合类型，或者是本机类ref类（需要有对象成员），或者是通过声明或继承被分配在垃圾回收堆或本机堆上的。"因此如果你有一个托管类型或者有一个有托管成员的本机类型，你就有了一个混合类型。VC++ Whidbey不直接支持混合类型(统一类型模型是一种Whidbey之后的概念)，但是它给我们划定了实现混合类型的条件。让我们开始讨论包含托管成员的本机类型。

ref class R { public: void F(){} //假定 non-trivial ctor/dtor R(){} ~R(){} };

　　在我的例子中，设想该托管类型R有一个non-trivial构造器和一个non-trivial析构器。

class Native { private: gcroot<R^> m_ref; public: Native(): m_ref(gcnew R()){} ~Native() { delete m_ref; } void DoF() { m_ref->F(); } };

　　既然，我不能在我的类中拥有一个R成员，我使用了gcroot模板类(在gcroot.h中声明，但是你要用"#include vcclr.h")，它包装了System::Runtime::InteropServices::GCHandle结构。它是个象类一样的灵敏指针，它重载了运算符->以返回用作模板参数的托管类型。因此在上面类中，我可以使用m_ref，就好象我已经声明它是R^，而且你能在DoF函数中看到这正在起作用。实际上你可以节省delete，这可以通过使用auto_gcroot(类似于std::auto_ptr，在msclr\auto_gcroot.h文件中声明)代替gcroot来实现。下面是一个更好些的使用auto_gcroot的实现。

class NativeEx { private: msclr::auto_gcroot<R^> m_ref; public: NativeEx() : m_ref(gcnew R()){} void DoF() { m_ref->F(); } };

　　下面让我们看相反的情形：一个CLI类的本机成员。

ref class Managed { private: Native* m_nat; public: Managed():m_nat(new Native()){ } ~Managed() { delete m_nat; } !Managed() { delete m_nat; #ifdef _DEBUG throw gcnew Exception("Oh, finalizer got called!"); #endif } void DoF() { m_nat->DoF(); } };

　　我不能定义一个Native对象来作为一个ref类成员，因此需要使用一个Native*对象来代替。我在构造器中new该Native对象，然后在析构器和finalizer中delete它。如果你运行该工程的调试版，在执行到finalizer时将抛出一个异常- 因此开发者可以马上添加一个对delete的调用或为他的CLI类型使用栈语义技术。奇怪的是，库开发小组没有建立一个gcroot的反向实现-但这不是个大问题，我们可以自己写。

template<typename T> ref class nativeroot { T* m_t; public: nativeroot():m_t(new T){} nativeroot(T* t):m_t(t){} T* operator->() { return m_t; } protected: ~nativeroot() { delete m_t; } !nativeroot() { delete m_t; #ifdef _DEBUG throw gcnew Exception("Uh oh, finalizer got called!"); #endif } };

　　这仅是个相当简单的灵敏指针实现，就象一个负责本机对象分配/回收的ref类。不管怎样，借助nativeroot模板类，我们可以如下修改托管类：

ref class ManagedEx { private: nativeroot<Native> m_nat; public: void DoF() { m_nat->DoF(); } };

　　好，关于混合类型的最大问题是什么呢？你可能问。最大问题是，现在你能混合使用你的MFC、ATL、WTL、STL代码仓库和.NET框架，并用可能的最直接的方式-只需写你的混合模式代码并编译实现!你可以建立在一个DLL库中建立MFC 类，然后建立一个.NET应用程序来调用这个DLL，还需要把.NET类成员添加到你的MFC类（也实现可以相反的情况）。

　　作为一例，设想你有一MFC对话框--它通过一个多行的编辑框接受来自用户的数据-现在，你有一新的要求-显示一个只读编辑框，它将显示当前在该多行编辑框中文本的md5哈希结果。你的队友正在悲叹他们将必须花费几个小时钻研crypto API，而你的上司在担忧你们可能必须要买一个第三方加密库；那正是你在他们面前树立形象的时候，你宣布你将在15分钟内做完这项任务。下面是解决的办法：

　　添加一个新的编辑框到你的对话框资源中，并且添加相应的DDX变量。选择/clr编译模式并且添加下列代码到你的对话框的头文件中：

#include <msclr\auto_gcroot.h> using namespace System::Security::Cryptography;

　　使用auto_gcroot模板来声明一个MD5CryptoServiceProvider成员：

protected: msclr::auto_gcroot<MD5CryptoServiceProvider^> md5;

　　在OnInitDialog过程中，gcnew MD5CryptoServiceProvider成员。

md5 = gcnew MD5CryptoServiceProvider();

　　并且为多行编辑框添加一个EN_CHANGE处理器：

void CXxxxxxDlg::OnEnChangeEdit1() { using namespace System; CString str; m_mesgedit.GetWindowText(str); array<Byte>^ data = gcnew array<Byte>(str.GetLength()); for(int i=0; i<str.GetLength(); i++) data[i] = static_cast<Byte>(str[i]); array<Byte>^ hash = md5->ComputeHash(data); CString strhash; for each(Byte b in hash) { str.Format(_T("%2X "),b); strhash += str; } m_md5edit.SetWindowText(strhash); }

　　这里使用了混合类型：一个本机Cdialog派生类，该类含有一个MD5CryptoServiceProvider成员(CLI类型)。你可以轻易地试验相反的情况（如早期的代码片断已显示的）——可以建立一个Windows表单应用程序而且可能想利用一个本机类库--这不成问题，使用上面定义的模板nativeroot即可。

5. 托管模板

　　也许你对泛型的概念已很清楚了，它帮助你避免进入C++的模板梦魇，它是实现模板的最佳方式，等等。好，假设这些全部正确，C++/CLI支持泛型就象任何其它CLI语言一样-但是它有而其它一些CLI语言还没有的是它还支持托管模板-也就是模板化的ref和value类。如果你以前从未使用过模板，你不能一下欣赏这么多优点，但是如果你有模板使用背景而且你已发现了泛型中存在的可能限制你编码的方式，托管模板将会大大减轻你的负担。你能联合使用泛型和模板- 事实上有可能用一个托管类型的模板参数来实例化一个泛型类型(尽管相反的情形是不可能的，因为运行时刻实例化由泛型所用)。STL.NET (或STL/CLR)以后讨论，请很好地利用泛型和托管模板的混合编程吧。

　　泛型使用的子类型约束机制将防止你写出下面的代码：

generic<typename T> T Add(T t1, T t2) { return t1 + t2; }

　　编译错误：

error C2676: binary ’+’ : ’T’ does not define this operator or a conversion to a type acceptable to the predefined operator

　　现在请看相应的模板版本：

template<typename T> T Add(T t1, T t2) { return t1 + t2; }

　　那么就可以这样做：

int x1 = 10, x2 = 20; int xsum = Add<int>(x1, x2);

　　还可以这样做：

ref class R { int x; public: R(int n):x(n){} R^ operator+(R^ r) { return gcnew R(x + r->x); } }; //... R^ r1 = gcnew R(10); R^ r2 = gcnew R(20); R^ rsum = Add<R^>(r1, r2);

　　这在一个象int的本机类型以及一个ref类型(只要ref类型有一个+运算符)情况下都能工作良好。这个泛型缺点不是一个调试错误或缺陷-它是设计造成的。泛型的实例化是在运行时通过调用配件集实现的，因此编译器不能确知一特定操作能被施行于一个泛型参数，除非它匹配一个子类型约束，因此编译器在定义泛型时解决这个问题。当你使用泛型时的另外一个妨碍是，它不会允许你使用非类型参数。下列泛型类定义不会编译：

generic<typename T, int x> ref class G{};

　　编译错：

error C2978: syntax error : expected ’typename’ or ’class’; found type ’int’; non-type parameters are not supported in generics

　　与托管模板相比较：

template<typename T, int x = 0> ref class R{};

　　如果你开始感激C++向你提供了泛型和托管模板，那么请看下面这一个例子：

template<typename T> ref class R{ public: void F() { Console::WriteLine("hey"); } }; template<> ref class R<int> { public: void F() { Console::WriteLine("int"); } };

　　你不能用泛型这样编码；否则，将产生：

　　编译错：error C2979: explicit specializations are not supported in generics

　　但可以在继承链中混合使用模板和泛型：

generic<typename T> ref class Base { public: void F1(T){} }; template<typename T> ref class Derived : Base<T> { public: void F2(T){} }; //... Derived<int> d; d.F1(10); d.F2(10);

　　最后，你不能从一个泛型参数类型派生一个泛型类。

　　下列代码不会成功编译：

generic<typename T> ref class R : T {};

　　error C3234: a generic class may not derive from a generic type parameter

　　模板让你这样做(好像你还不知道这些)：

ref class Base{ public: void F(){} }; generic<typename T> ref class R : T {}; //... R<Base> r1; r1.F();

　　这样，当你下次遇到对泛型的贬谤时，你就知道该怎么做了。

　　6. STL/CLR

　　当大量使用STL的C++开发者转向.NET1/1.1时一定感觉非常别扭，他们中的许多可能会放弃并转回到原来的本机编码。从技术上讲，你能结合.NET类型(using gcroot)使用本机STL，但是产生的结果代码可能相当低效，更不用说是丑陋了：

std::vector< gcroot<IntPtr> >* m_vec_hglobal; //... for each(gcroot<IntPtr> ptr in *m_vec_hglobal) { Marshal::FreeHGlobal(ptr);}

　　大概VC++小组考虑到了这些并决定在Whidbey以后，他们会提供STL.NET（或STL/CLR）并可以单独从网上下载。

　　你可能问为什么？Stan Lippman，在他的MSDN文章(STL.NET Primer)中给出了3条原因：

　　·可扩展性--STL设计把算法和容器隔离到自己的应用空间-也就是你可以有一组容器和一组算法，并且你能在任何一个容器上使用这些算法；同时你能在任何一个算法中使用这些容器。因此，如果你添加一种新的算法，你能在任何一种容器中使用它；同样，一个新的容器也可以与现有算法配合使用。

　　·统一性--所有核心C++开发者集中在一起，汇集起他们精妙的STL专长，再使用他们的专长则轻车熟路。要较好地使用STL需要花费时间-然而一旦你掌握了它，你就有了在.NET世界中使用你的技巧的明显优势。不是吗？

　　·性能--STL.NET通过使用实现泛型接口的托管模板实现。并且既然它的核心已用C++和托管模板编码，可以期盼它比在BCL上使用的泛型容器更具有性能优势。

　　使用过STL的人不需要任何示范，所以下面代码有益于以前没有使用过STL的人。

vector<String^> vecstr; vecstr.push_back("wally"); vecstr.push_back("nish"); vecstr.push_back("smitha"); vecstr.push_back("nivi"); deque<String^> deqstr; deqstr.push_back("wally"); deqstr.push_back("nish"); deqstr.push_back("smitha"); deqstr.push_back("nivi");

　　我使用了两个STL.NET容器-vector和deque，并装满两个容器，使其看起来相同(在两个容器中都使用了push_back)。现在，我将在两个容器上使用replace算法-我们再次看到，这些代码是很相同的。

replace(vecstr.begin(), vecstr.end(), gcnew String("nish"), gcnew String("jambo")); replace(deqstr.begin(), deqstr.end(), gcnew String("nish"), gcnew String("chris"));

　　这里特别要注意的是我使用了"同样"的算法--replace并在两个不同STL容器上使用相同的函数调用。这是当Stan谈及"可扩展性"时的意思。下面我用一个简单函数来证明：

template<typename ForwardIterator> void Capitalize( ForwardIterator first，ForwardIterator end) { for(ForwardIterator it = first; it < end; it++) *it = (*it)->ToUpper(); }

　　它遍历一个System::String^容器并把其中的每个字符串转化为大写。

Capitalize(vecstr.begin(), vecstr.end()); Capitalize(deqstr.begin(), deqstr.end()); for(vector<String^>::iterator it = vecstr.begin(); it < vecstr.end(); it++) Console::WriteLine(*it); Console::WriteLine(); for(deque<String^>::iterator it = deqstr.begin(); it < deqstr.end(); it++) Console::WriteLine(*it);

　　上面我的算法能够与vector和deque容器工作良好。至此，不再细谈；否则，guru站上的STL爱好者们会对我群起攻击，而非STL人可能感到厌烦。如果你还没使用过STL，可以参考有关资料。

7. 熟悉的语法

　　开发者经常迷恋他们所用的编程语言，而很少是出于实用的目的。还记得当微软宣布不再为VB6提供官方支持时，VB6人的反抗吗？非VB6人对此可能非常震惊，而老道的VB6人早已为他们的语言作好葬礼准备了。事实上，如果VB.NET从来没被发明，多数VB6人将会离开.NET，因为C#将会对他们非常陌生，而它的祖先就是C++。如今，许多VB.NET人可能已经转向了C#，但是他们不会从VB6直接转向C#；VB.NET起到一个桥梁作用让他们的思想脱离开原来VB6思想。相应地，如果微软仅发行VB.NET(而没有C#)，那么.NET可能成为了新的面向对象VB，且带有一个更大的类库-C++社团的人可能对此嗤之以鼻-他们甚至不会麻烦地检验.NET基础类库。为什么任何使用一种特定语言的开发者会对另外一个团体的使用另外开发语言的开发者嗤之以鼻？这不是我要回答的问题。--要回答该问题也许要先回答为什么有的人喜欢威士忌，有的人喜欢可口可乐，而还有人喜欢牛奶。所有我要说的是，对开发者来说，语法家族是个大问题。

　　你认为对于一个具有C++背景的人，下面的代码具有怎样的直觉性？

char[] arr =new char[128];

　　他/她可能回答的第一件事是，方括号放错了位置。下面这句又如何？

int y=arr.Length;

　　"呀!"-最可能的反映。现在把下面与前面相比较：

char natarr[128]; array<char>^ refarr=gcnew array<char>(128); int y=refarr->Length;

　　请注意声明一个本机数组和一个托管数组时的语法区别。这里不同的模板形式的语法可视化地告诫开发者这一事实--refarr并不是典型的C++数组而且它可能是某种CLI类的派生物(事实上确是如此)，所以极有可能可以把方法和属性应用于它。

　　C#的finalizer语法最有可能引起转向C#的C++程序员的混淆。请看见下列C#代码：

class R { ~R(){} }

　　好，这样~R看起来象一个析构器但实际是个finalizer。为什么？请与下面的C++代码比较：

ref class R { ~R(){ } !R(){ } };

　　这里~R是析构器（实际上等价于一个析构器的Dispose模式-但对C++人员来说，这它的行为象个析构器）而新的!R语法是为finalizer建立的-这样就不再有混淆而且语法看上去也与本机C++相匹配。

　　请看一下C#泛型语法：

class R<T>{};

　　再请看一下C++的语法：

generic<typename T> ref class R{};

　　曾经使用过模板的人马上就看出这种C++语法，而C#语法不能保证其没有混淆性且也不直观。我的观点是，如果你以前具有C++背景，C++/CLI语法将最贴近于你以前所用。C#(以及J#)看上去象C++，但是还有相当多的极为使人烦火的奇怪语义差别而且如果你没有完全放弃C++，语法差别将永远不停地带给你混乱和挫折。从这种意义上说，我认为VB.NET更好些，至少它有自己唯一的语法，所以那些共用C++和VB.NET的人不会产生语法混乱。

　　8. 结论

　　最后，至于你用什么语言编程，这可能依赖许多因素——如：你在学校学习的是什么语言，你是用什么语言开发的现有代码仓库，是否你的客户对你有具体的语言要求等。本文的主要目的是帮助你确定使用C++/CLI的几个明确的场所--这里，它比另外CLI语言更具有明显优势。如果你开发的应用程序有90%的使用时间是涉及本机interop，为何还要考虑使用另外的而不是C++？如果你想开发一个通用集合，为什么仅把你自己限制在泛型上，而不是结合泛型和模板的优势呢？如果你已经用C++工作，为什么还要学习一种新的语言?我常觉得象C#和VB.NET这样的语言总是尽量向开发者隐藏CLR，而C++不仅让你品味CLR，甚至可以让你去亲吻CLR! 

一 引言

作为一名windows系统上图形软件开发者已经有3个多年头了，在此过程中有不少的经历和经验，非常高兴与大家分享，今天主要是《windows via C++》一书的阅读心得，所以主要谈到的是windows上C++的开发。

二 C++语言

我们知道C++是一门ISO的面向对象的语言，下面我介绍他的三个方面，也正是这三个主要方面决定了他被广泛的使用。第一，C++是一个功能强大的语言。比如C++语言本身提供的基于C语言的内嵌类型，数组，结构体和指针等，C++比C新加入的面向对象的Class，继承，多态和模板等，还有C++标准模板库（STL）提供的实际开发当中常用的数据结构和算法的实现；第二，大量的开源和第三方库，如果在windows上使用C++开发，我们还可以借助microsoft对C++提供的强有力的支持，首先的VS编译器，还有UI库MFC，还有ATL等；除此之外我们还可以看到其他的许多非microsoft的开源的和第三方的支持，比如说Boost很大程度的扩充了STL，提供了更多更高级的功能，还有Loki把C++与设计模式结合起来，还有很多的第三方的UI库，比如QT，WxWindows，WTL，GTK等，第三方的网络通信库，比如ACE，StreamModule等，第三那的XML库，比如Xerces，CMarkup，tinyxml等，第三方的科学计算库，比如Blitz++，MTL等，第三方的游戏开发库，比如OGRE，KlayGE等，第三方的线程库，比如C++ Threads，ZThreads等，还有其他的很多。第三，C++的高性能。这个也是毋庸质疑的，我们知道的大部分的操作系统，嵌入式开发，游戏，图像软件离不开C++，这都是跟C++的高性能有很大的关系。但从这一点来看，这就是很多现代的其他的高级语言没有的，所以C++以后仍然有很长的路要走。

三 《Windows via c++》之经典

上面说了C++语言本身，这里具体到windows系统上C++的开发，我们要基于windows系统开发软件，就难免的要和windows系统打交道，比如系统本身对字符编码的支持，系统的异常处理机制，线程的创建管理，进程的创建管理，内存和虚拟内存的使用，堆栈的操作，DLL的使用等。上面提到的这些都不是C++语言本身的职责，是需要操作系统提供的支持，而所有这些内容正是《windows via C++》所覆盖的内容，也正是本书很好的把C++和Windows连接起来，引领C++程序员走向windows的底层，这也正是本书的经典之处!再次感谢作者Jeffrey Richter的伟大贡献！

1）字符编码：字符编码作为字符串的基础，自然而然就成了我们软件开发必不可缺少的基石，那么什么是字符编码那？字符编码就是字符在计算机内部的表示形式，我们都知道在计算机内部，所有的信息最终都表示为一个二进制的字符串。每一个二进制位（bit）有0和1两种状态，因此八个二进制位就可以组合出256种状态，这被称为一个字节（byte）。上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码，一直沿用至今。ASCII码一共规定了128个字符的编码，因为他只占用了一个字节的后面7位，最前面的1位统一规定为0。英语用128个符号编码就够了，但是用来表示其他语言，128个符号是不够的。所以后来就各国有了各国的编码，比如日文中的汉字远远大于256个，所以日文使用如果第一个字符在0 x 8 1 与0 x 9 F 之间，或者在0 x E 0 与0 x F C 之间，那么就必须观察下一个字节，才能确定字符串中的这个完整的字符。这样他就使用一个或两个字节来表示一个字符，这种编码被称为双字节字符集（D B C S ）。由于世界上存在着多种编码方式，这使得同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。这个时候Unicode就出现了他将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，那么乱码问题就会消失。但是unicode也有不同的实现，主要的有三种：UTF-16：其本身就是标准的Unicode编码方案，又称为UCS-2，它固定使用16 bits(两个字节)整数来表示一个字符。UTF-32：又称为UCS-4，它固定使用32 bits(四个字节)整数来表示一个字符。UTF -8：最广泛的使用的UTF方案，UTF-8使用可变长度字节来储存Unicode字符，例如ASCII字母继续使用1字节储存，重音文字、希腊字母或西里尔字母等使用2字节来储存，而常用的汉字就要使用3字节。辅助平面字符则使用4字节。UTF-8更便于在使用Unicode的系统与现存的单字节的系统进行数据传输和交换。与前两个方案不同：UTF-8以字节为编码单元，没有字节序的问题。但是不管是哪种unicode的实现都可以包含世界所有的字符，解决软件本地化的难题。

Windows在2000以前使用ASCII，2000及以后的系统都使用unicode来编码，但是需要注意的是Windows2000既支持Unicode，也支持ANSI，因此可以为任意一种开发应用程序.如果调用任何一个Windows函数并给它传递一个ANSI字符串，那么系统首先要将字符串转换成Unicode，然后将Unicode字符串传递给操作系统。如果希望函数返回ANSI字符串，系统就会首先将Unicode字符串转换成ANSI字符串，然后将结果返回给你的应用程序。所有这些转换操作都是在你看不见的情况下发生的。当然，进行这些字符串的转换需要占用系统的时间和内存。比如同一个函数CreateWindowEx()，在内部其实是当ASCII是调用CreateWindowExA()，而当unicode时调用CreateWindowExW()。同时windows系统还给我们提供了ASCII和unicode间的转化函数MultiByteToWideChar(）和WideCharToMultiByte()。

2）进程和线程：进程通常被定义为一个正在运行的程序的实例，它由两个部分组成，第一， 一个是操作系统用来管理进程的内核对象，内核对象也是系统用来存放关于进程的统计信息的地方；第二，是地址空间，它包含所有可执行模块或 D L L 模块的代码和数据，它还包含动态内存分配的空间，如线程堆栈和堆分配空间。线程是应用程序执行时的最小单位，同样线程也是由两个部分组成的：第一， 一个是线程的内核对象，操作系统用它来对线程实施管理，内核对象也是系统用来存放线程统计信息的地方；第二，线程堆栈，它用于维护线程在执行代码时需要的所有函数参数和局部变量。

进程是不活泼的，从来不执行任何东西，它只是线程的容器，若要使进程完成某项操作，它必须拥有一个在它的环境中运行的线程，该线程负责执行包含在进程的地址空间中的代码，当创建一个进程时，系统会自动创建它的第一个线程，称为主线程，然后，该线程可以创建其他的线程，而这些线程又能创建更多的线程。如果在单进程环境中，你有两个或多个线程正在运行，那么这两个线程将共享单个地址空间。这些线程能够执行相同的代码，对相同的数据进行操作。这些线程还能共享内核对象句柄，因为句柄表依赖于每个进程而不是每个线程存在。

windows提供和很多函数来创建和管理线程和进程，比如CreateThread（），ExitThread（），TerminateThread（），GetCurrentThread()，CreateProcess（），ExitProcess（），TerminateProcess （），GetCurrentProcess（）等。

3）线程同步和线程局部存储：由于同一进程的所有线程共享进程的虚拟地址空间，并且线程的中断是汇编语言级的，所以可能会发生两个线程同时访问同一个对象（包括全局变量、共享资源、API函数和MFC对象等）的情况，这有可能导致程序错误。属于不同进程的线程在同时访问同一内存区域或共享资源时，也会存在同样的问题。因此，在多线程应用程序中，常常需要采取一些措施来同步线程的执行。

windows提供了3中同步机制，分别是信号量Semaphore，互斥量Mutex，关键代码段CriticalSection。其中信号量Semaphore，是一个可以限制对指定的临界段进行访问的线程的数目的数据结构。互斥量Mutex和关键代码段CriticalSection，他们的作用是相同的，都是用来保证某时刻只有一个线程能够访问全局或静态的资源。区别是：Mutex是内核对象，可以设置等待超时时间，可以在不同的进程的线程中使用，但是所消耗的时间也比较多。CriticalSection与Mutex相反。

线程局部存储（TLS），可以为全局或静态变量对不同的线程有不同的拷贝。

4）线程池：可以实现在程序中根据需要动态的创建线程，比如在server端，根据访问的用户的多少来创建线程的多少。在windows2000以后增加了创建线程池的API，比如 QueueUserWorkItem（）。

5) 纤程：用户级的线程机制，比线程小的单位，开发人员负责管理纤程的调度，同时负责确定纤程何时在线程时间片上下文中运行，一般不会带来性能的提高，主要的目的是为开发人员调度多个不需要并行执行的任务提供一个便捷的机制。单线程可以包含一个或多个纤程。就内核而言，线程是抢占调度的，是正在执行的代码。然而，线程每次执行一个纤程的代码，你决定究竟执行哪个纤程，你可以调用ConvertThreadToFiber（）将已有的线程转化位纤程，当对纤程的执行环境进行分配和初始化后，就可以将执行环境的地址与线程关联起来，该线程被转换成一个纤程，而纤程则在该线程上运行。现在，如果你的纤程（线程）返回或调用ExitThread函数，那么纤程和线程都会终止运行。除非打算创建更多的纤程以便在同一个线程上运行，否则没有理由将线程转换成纤程。若要创建另一个纤程，该线程（当前正在运行纤程的线程）可以调用CreateFiber函数。但是调用CreateFilber创建的纤程并不执行，直到调用SwitchToFiber函数。若要撤消纤程，可以调用DeleteFiber函数。

6) 作业：作业可以看作是一组进程的容器,把这些进程当作一个整体,对这个整体整个加入更多的限制. 因为Windows并不维护进程之间的父/子关系。即使父进程已经终止运行，子进程仍然会继续运行。Microsoft Windoss 2000提供了一个新的作业内核对象，使你能够将进程组合在一起，并且创建一个“沙框”，以便限制进程能够进行的操作。最好将作业对象视为一个进程的容器。但是，创建包含单个进程的作业是有用的，因为这样一来，就可以对该进程加上通常情况下不能加的限制。创建一个新作业内核对象可以调用CreateJobObject（），另一个进程要访问作业，可以通过OpenJobObject（），应该知道，关闭作业对象并不会迫使作业中的所有进程终止运行。该作业对象实际上做上了删除标记，只有当作业中的所有进程全部终止运行之后，该作业对象才被自动撤消。注意，关闭作业的句柄后，尽管该作业仍然存在，但是该作业将无法被所有进程访问。通过调用SetInformationJobObject()可以给作业加上各种限制.查询限制QueryInformationJobObject（），将进程放入作业AssignProcessToJobObject（），若要撤销作业中的进程调用TerminateJobObject（）。

7) 虚拟内存，内存映射文件和堆栈：每个进程都被赋予它自己的虚拟地址空间。对于3 2位进程来说，这个地址空间是4 G B,其中默认有2G是用户可以使用的。由于每个进程可以接收它自己的私有的地址空间，因此当进程中的一个线程正在运行时，该线程可以访问只属于它的进程的内存。属于所有其他进程的内存则隐藏着，并且不能被正在运行的线程访问。注意在Windows 2000中，属于操作系统本身的内存也是隐藏的，正在运行的线程无法访问。这意味着线程常常不能访问操作系统的数据。

Windows提供了3种进行内存管理的方法，它们是第一， 虚拟内存，最适合用来管理大型对象或结构数组。 第二，内存映射文件，最适合用来管理大型数据流（通常来自文件）以及在单个计算机上运行的多个进程之间共享数据。第三， 内存堆栈，最适合用来管理大量的小对象。

在较老的操作系统中，物理存储器被视为计算机拥有的R A M的容量。换句话说，如果计算机拥有1 6 M B的R A M，那么加载和运行的应用程序最多可以使用1 6 M B的R A M。今天的操作系统能够使得磁盘空间看上去就像内存一样。磁盘上的文件通常称为页文件，它包含了可供所有进程使用的虚拟内存。

内存映射文件与虚拟内存一样，内存映射文件可以用来保留一个地址空间的区域，并将物理存储器提交给该区域。它们之间的差别是，物理存储器来自一个已经位于磁盘上的文件，而不是系统的页文件。一旦该文件被映射，就可以访问它，就像整个文件已经加载内存一样。

堆栈可以用来分配许多较小的数据块。例如，若要对链接表和链接树进行管理，最好的方法是使用堆栈，堆栈的优点是，可以不考虑分配粒度和页面边界之类的问题，集中精力处理手头的任务。堆栈的缺点是，分配和释放内存块的速度比其他机制要慢，并且无法直接控制物理存储器的提交和回收。进程和线程都有自己的堆栈，而且大小可以更改。

8) DLL使用：windows中广泛的使用dll来实现模块化，dll的使用一般有静态和动态加载，静态加载一般通过编译器的设置来实现，动态加载通过使用loadlibrary（）和freelibrary（）来实现。

9）结构化异常处理（SEH）：SEH 是 Windows 系统提供的异常处理功能，跟开发工具无关。windows上其他程序中的异常处理一般底层都是转化为SEH来实现。实际上，当你写一条C++ throw语句时，编译器就生成一个对Windows的RaiseException函数的调用。用于throw语句的变量传递给RaiseException作为附加的参数。

四 《Windows via c++》之新增

1）64位支持：最新的系统有64的版本，这样的话进程就不再有最大4G的内存限制，但是由于64位系统与以前的32位系统其实是一个codebase，所以基本有所的接口都与以前32位保持椅子，这样的话我们以前的所有的32位的程序只需要从新编译就可以运行在64系统上，需要特别注意的是指针和句柄的从32位到64位的转变。

2）windows vista/2008特有：提供了更加安全的stirng函数，一些内核对象的改变等。

3）可重复使用的代码：大量可在我们日常开发中重复使用的代码和让我们更好的理解进程的源代码processInfo，LockCop等。

五 总结

总之，通过阅读《Windows via C++》使我们更好的了解windows系统，更好的在windows进行C++开发！推荐windows上C++开发人员可以一读！

3D CAD软件及核心

一 3D CAD软件

1）CATIA （达索Dassault Aviation）（高端）（）

CATIA是英文 Computer Aided Tri-Dimensional Interface Application 的缩写。是世界上一种主流的CAD/CAE/CAM一体化软件。在70年代Dassault Aviation 成为了第一个用户，CATIA 也应运而生。从1982年到1988年，CATIA 相继发布了1版本、2版本、3版本，并于1993年发布了功能强大的4版本，现在的CATIA 软件分为V4版本和 V5版本两个系列。V4版本应用于UNIX 平台，V5版本应用于UNIX和Windows 两种平台。V5版本的开发开始于1994年。为了使软件能够易学易用，Dassault System 于94年开始重新开发全新的CATIA V5版本，新的V5版本界面更加友好，功能也日趋强大，并且开创了CAD/CAE/CAM 软件的一种全新风格。
  
    法国 Dassault Aviation 是世界著名的航空航天企业。其产品以幻影2000和阵风战斗机最为著名。CATIA的产品开发商Dassault System 成立于1981年。而如今其在CAD/CAE/CAM 以及PDM 领域内的领导地位，已得到世界范围内的承认。其销售利润从最开始的一百万美圆增长到现在的近二十亿美圆。雇员人数由20人发展到2，000多人。
  
    CATIA是法国Dassault System公司的CAD/CAE/CAM一体化软件，居世界CAD/CAE/CAM领域的领导地位，广泛应用于航空航天、汽车制造、造船、机械制造、电子\电器、消费品行业，它的集成解决方案覆盖所有的产品设计与制造领域，其特有的DMU电子样机模块功能及混合建模技术更是推动着企业竞争力和生产力的提高。CATIA 提供方便的解决方案，迎合所有工业领域的大、中、小型企业需要。包括:从大型的波音747飞机、火箭发动机到化妆品的包装盒，几乎涵盖了所有的制造业产品。在世界上有超过13,000的用户选择了CATIA。CATIA 源于航空航天业，但其强大的功能以得到各行业的认可，在欧洲汽车业，已成为事实上的标准。CATIA 的著名用户包括波音、克莱斯勒、宝马、奔驰等一大批知名企业。其用户群体在世界制造业中具有举足轻重的地位。波音飞机公司使用CATIA完成了整个波音 777的电子装配，创造了业界的一个奇迹，从而也确定了CATIA 在CAD/CAE/CAM 行业内的领先地位。

2）UG （UGS现被西门子收购）（高端）（Parasolid几何造型核心为基础，采用基于约束的特征建模技术和传统的几何建模为一体的复合建模技术）

Unigraphics Solutions公司(简称UGS)是全球著名的MCAD供应商,主要为汽车与交通、航空航天、日用消费品、通用机械以及电子工业等领域通过其虚拟产品开发(VPD)的理念提供多级化的、集成的、企业级的包括软件产品与服务在内的完整的 MCAD解决方案。其主要的CAD产品是UG。
UG公司的产品主要有为机械制造企业提供包括从设计、分析到制造应用的Unigraphics软件、基于Windows的设计与制图产品Solid Edge、集团级产品数据管理系统iMAN、产品可视化技术ProductVision以及被业界广泛使用的高精度边界表示的实体建模核心 Parasolid在内的全线产品。
UG在航空航天、汽车、通用机械、工业设备、医疗器械以及其它高科技应用领域的机械设计和模具加工自动化的市场上得到了广泛的应用。多年来，UGS一直在支持美国通用汽车公司实施目前全球最大的虚拟产品开发项目，同时Unigraphics也是日本著名汽车零部件制造商DENSO公司的计算机应用标准，并在全球汽车行业得到了很大的应用，如Navistar、底特律柴油机厂、Winnebago和Robert Bosch AG 等。
另外，UGS公司在航空领域也有很好的的表现：在美国的航空业，安装了超过10,000套UG软件；在俄罗斯航空业，UG软件具有90%以上的市场；在北美汽轮机市场，UG软件占80%。UGS在喷气发动机行业也占有领先地位，拥有如Pratt & Whitney和GE 喷气发动机公司这样的知名客户。航空业的其它客户还有：B/E航空公司、波音公司、 以色列飞机公司、英国航空公司、Northrop Grumman、伊尔飞机和Antonov。
UGS公司的产品同时还遍布通用机械、医疗器械、电子、高技术以及日用消费品等行业，如：3M、Will-Pemco、Biomet、Zimmer、飞利浦公司、吉列公司、Timex、 Eureka 和Arctic Cat等。

3）Pro/ENGINEER（PTC）（中端）(PROE是参数化造型的开创者，以其参数化、基于特征、全相关等概念闻名于CAD界)

1985年，PTC公司成立于美国波士顿，开始参数化建模软件的研究。1988年，V1.0的Pro/ENGINEER诞生了。经过10余年的发展，Pro/ENGINEER已经成为三维建模软件的领头羊。目前已经发布了Pro/ENGINEER2000i2。PTC的系列软件包括了在工业设计和机械设计等方面的多项功能，还包括对大型装配体的管理、功能仿真、制造、产品数据管理等等。Pro/ENGINEER还提供了目前所能达到的最全面、集成最紧密的产品开发环境。PRO/E的最新版本为PRO/E2000i，它可运行于Windows/NT和UNIX平台上，共有六大主模块，下面我把它们逐一介绍给大家。

PRO/E概述
PRO/ENGINEER软件包的产品开发环境在支持并行工作，它通过一系列完全相关的模块表述产品的外形、装配及其他功能。PRO/E能够让多个部门同时致力于单一的产品模型。包括对大型项目的装配体管理、功能仿真、制造、数据管理等。其中PRO/E V2000I更增加了行为建模技术使其成为把梦想变为现实的杰出工具。

4）solidworks（SolidWorks被达索收购）（低端）（Parasolid几何造型核心为基础，采用基于约束的特征建模技术和传统的几何建模为一体的复合建模技术）

SolidWorks公司成立于1993年，由PTC公司的技术副总裁与CV公司的副总裁发起，总部位于马萨诸塞州的康克尔郡（Concord,Massachusetts）内，当初所赋予的任务是希望在每一个工程师的桌面上提供一套具有生产力的实体模型设计系统。从1995年推出第一套SolidWorks三维机械设计软件至今，它已经拥有位于全球的办事处，并经由300家经销商在全球140个国家进行销售与分销该产品。　SolidWorks软件是世界上第一个基于Windows开发的三维CAD系统，由于技术创新符合CAD技术的发展潮流和趋势，SolidWorks 公司于两年间成为CAD/CAM产业中获利最高的公司。良好的财务状况和用户支持使得SolidWorks每年都有数十乃至数百项的技术创新，公司也获得了很多荣誉。该系统在1995-1999年获得全球微机平台CAD系统评比第一名；从1995年至今，已经累计获得十七项国际大奖，其中仅从1999年起，美国权威的CAD专业杂志CADENCE连续4年授予SolidWorks最佳编辑奖，以表彰SolidWorks的创新、活力和简明。至此，SolidWorks所遵循的易用、稳定和创新三大原则得到了全面的落实和证明，使用它，设计师大大缩短了设计时间，产品快速、高效地投向了市场。
    由于SolidWorks出色的技术和市场表现，不仅成为CAD行业的一颗耀眼的明星，也成为华尔街青睐的对象。终于在1997年由法国达索公司以三亿一千万美元的高额市值将SolidWorks全资并购。公司原来的风险投资商和股东，以一千三百万美元的风险投资，获得了高额的回报，创造了CAD行业的世界纪录。并购后的SolidWorks以原来的品牌和管理技术队伍继续独立运作，成为CAD行业一家高素质的专业化公司，SolidWorks三维机械设计软件也成为达索企业中最具竞争力的CAD产品。

5) autodesk inventor(autodesk)(低端)（）
Autodesk Inventor 2008产品线提供了一套全面、集成的设计工具，可用于三维设计和建档、创建布线系统和验证设计。 Inventor产品线中的所有产品包均包括强大的数据管理软件和面向二维制图和详细设计的 AutoCAD Mechanical软件。

6)solidege(UGS现被西门子收购)(低端)

二 3D CAD软件核心

1）ACIS是用C＋＋语言编写的，由于没有基于ACIS的高中端CAD软件开发出来，ACIS的维护和提供实时的技术支持看起来要比Parasolid差点。总言之，ACIS的稳定性较差，但容易上手，适用于学校里的研究工作或做个DEMO版演示软件；

2）OpenCasCade是个免费包，适用于市场份额不大的软件开发。比如CMM测量软件，CMM软件一年销售几千套已经是非常好的业绩了。OpenCasCade用于学习研究还是不错的，算法都看得到，不过这是需要良好的数学（比如：高等几何）功底的。

3）Parasolid包里的复杂的曲面造型功能看起来UGS公司有所保留，不过，UGS最近被西门子收购，纯粹的软件行业看起来比较脆弱，前几年的网络泡沫，现在看起来软件泡沫也不远了。

4）ACIS和Parasolid价格差不多，如果是商业开发的话，还是选择Parasolid稳妥点。

三 3D CAD软件选择

几种三维软件的特点结合我的经验对比：
1）Solidworks：用法简单，对于非复杂曲面实体建模能力还可以；
2）UG：功能强大，操作一般，作模具较好；
3）CATIA：功能强大，是当今一流的三维软件，但是操作复杂，一般公司不用，像波音等大公司使用，在中国汽车行业常用；
4) PRO/E：功能强大，操作简单，曲面能力强，适用于产品外观模型的建立与结构的设计，制作模具能力较差。
至于3DMAX之流，根本不是三维CAD软件，不值一提。

　　20世纪50年代

　　1955年10月28日

　　威廉-亨利·盖茨三世出生于西雅图。祖母奥黛丽给他起了一个外号——“特利”(Trey)，Trey在英语中的意思是三点的牌、骰子或骨牌。盖茨后来也确实成了一名扑克牌高手。

　　20世纪60年代

　　1967年

　　盖茨上六年级，学习成绩不佳，他充满困惑地问妈妈，“您曾尝试思考吗？”

　　1967年秋

　　盖茨的父母把他送进了湖边学校(Lakeside School)，这是西雅图一所男子学校。他是班里最矮的学生。

　　1968年

　　盖茨和湖边学校同班同学保罗·艾伦(Paul Allen)从手册中学会了Basic语言。几周后，这两个小家伙便将学校用于支付PDP-10电脑使用时间的3000美元年度预算花得一干二净。他们俩不久即与电脑中心公司签了一份合约，向其报告PDP-10电脑中存在的软件缺陷，而报酬是免费使用电脑。

　　20世纪70年代

　　1971年

　　盖茨为湖边学校编写程序，包括一个设计班级课程表的程序。

　　1973年9月

　　盖茨考入哈佛大学。他的学习成绩很不稳定。他有很多坏习惯，经常旷课去编程、玩牌，不爱洗澡，喜欢比萨饼和碳酸饮料。他与住在同一个宿舍的史蒂夫·鲍尔默(Steve Ballmer)结为好友。

　　1975年1月

　　艾伦无意中看到了《大众电子》的封面，上面是Altair 8800电脑的照片和“全球第一台对抗商业模式的微型电脑装置”的大字标题。艾伦买了一本，并冲进盖茨的房间。几天后，盖茨给Altair电脑制造商 MITS打去电话，告诉该公司他和艾伦能为8800电脑开发出Basic语言。

　　1975年2月1日

　　盖茨和艾伦完成Basic开发，将其以3000美元外加最高达18万美元的版税卖给MITS公司。

　　1976年11月26日

　　盖茨和艾伦注册了微软(Microsoft)商标。他们一度考虑以艾伦与盖茨(Allen & Gates)作为公司名称，后提出Micro-Soft，但他们决定将中间的连字符去掉，于是微软就此诞生。当时艾伦23岁，盖茨21岁。

　　1977年1月

　　盖茨从哈佛大学休学，在新墨西哥州阿尔伯克基创建了微软，MITS总部也设在此地。

　　1977年

　　盖茨的秘书多次在微软办公大楼内发现盖茨躺在地板上呼呼大睡。他仍喜欢吃比萨饼，同时对属下要求严格，经常与同事争辩。盖茨经常说的一句话是：“这是我有史以来听说的最愚蠢的事情。”

　　1977年底

　　盖茨多次因驾驶保时捷911超速而被警方逮捕，还有一次则是无照驾驶。这可害苦了艾伦，他保释盖茨的经历至少有一次。

　　1978年12月

　　微软年终销售额超过100万美元。

　　1979年1月1日

　　微软将公司总部迁至华盛顿州贝尔维尤市。

　　20世纪80年代

　　1980年8月28日

　　盖茨与IBM签署合同，同意为这家PC制造商开发软件。后来，他以5万美元买了一套名为QDOS的操作系统，稍加改进并更名为DOS，便授权IBM使用。

　　1981年8月12日

　　IBM开始销售具有MS-DOS 1.0的PC。

　　1982年

　　在上市销售的第一年，MS-DOS被授权于50个硬件制造商使用。

　　1983年2月18日

　　艾伦因身患霍奇金氏病被迫辞去微软副总裁一职。他买了一个篮球队，创建了一个音乐博物馆，拥有世界上第三大游艇。

　　1983年11月10日

　　Windows揭开神秘面纱。Windows是MS-DOS的延伸，可提供图形用户界面。

　　1984年1月24日

　　盖茨出席了Macintosh的上市宣传活动——微软是第一批为苹果电脑开发软件的公司之一。

　　1985年

　　有报道称盖茨粗暴辱骂一位女高管，后者要求调离岗位。

　　1985年8月12日

　　经过10年的奋斗，微软产品的销售额达到1.4亿美元。

　　1986年3月13日

　　微软以每股21美元公开发售股票。当天微软股价报收于28美元，为公司筹集到6100万美元。

　　1987年

　　盖茨在曼哈顿召开的微软新闻发布会上邂逅梅琳达·弗朗奇(Melinda French)。

　　1989年8月1日

　　微软推出Office办公软件。

　　20世纪90年代

　　1990年5月13日

　　盖茨在母亲节这一天提出微软公司高层退休时间表。

　　1990年6月

　　美国联邦贸易委员会对微软和IBM在PC软件市场可能存在的勾结行为展开调查。

　　1993年4月11日

　　在从佛罗里达州飞往西雅图的包机上，盖茨向梅琳达求婚。盖茨还安排飞机在奥马哈降落，带着梅琳达同好友沃伦·巴菲特(Warren Buffett)一同出去购物。

　　1993年8月20日

　　美国司法部从联邦贸易委员会接管对微软的调查。

　　1994年1月1日

　　盖茨和梅琳达在夏威夷拉奈小岛上举行了小型婚礼。为给新婚妻子一个惊喜，盖茨特意安排梅琳达最喜欢的歌手威利·尼尔森(Willie Nelson)在婚礼上表演。

　　1994年4月

　　好消息：盖茨首次登上了《连线》杂志封面。坏消息：美国政府对微软展开了反垄断调查。

　　1994年7月

　　微软同意接受美国政府签署的法令，承诺放弃极端的反竞争商业行为(例如，要求硬件制造商为其所生产的配置特定微处理器的所有电脑支付MS-DOS授权费，即使该电脑没有安装这一操作系统)。

　　1994年11月11日

　　盖茨以3080万美元购得达·芬奇的《哈默手稿》(Codex Hammer)——达·芬奇亲笔写下的72页科学手稿。他同意将《哈默手稿》公开展示。

　　1995年

　　盖茨出现在可口可乐(据报道他喜欢喝健怡可乐)的商业广告中：这位亿万富翁搜遍全身口袋，寻找购买饮料的零钱。

　　1995年7月17日

　　39岁的盖茨以129亿美元的个人财富成为世界首富。微软在1995年的收入达到59亿美元，拥有17,801名员工。

　　1995年8月24日

　　微软推出网络浏览器Internet Explorer。

　　1996年6月

　　盖茨第二次登上《连线》杂志封面，这次是用Photoshop软件处理过的他裹着浴袍的照片。

　　1996年12月

　　微软股价创下新高——同比上涨88%。从理论上讲，那一年，盖茨每天的收入高达3000万美元。

　　1997年10月20日

　　因违反1994年签署的协议，美国法院对微软处以每天100万美元的罚款。美国司法部称，微软要求硬件制造商申请Windows 95授权时，必须在其硬件产品中绑定Internet Explorer，由此违反了这一协议。

　　1998年2月4日

　　盖茨在比利时布鲁塞尔会见比利时政府官员和企业家时，遭到奶油蛋糕的袭击。事后，盖茨开玩笑说，“这块蛋糕可不怎么好吃”。

　　1998年5月18日

　　美国司法部和20个州的总检察官认为微软将网络浏览器绑定到其操作系统，违反了相关规定，由此对微软提出起诉。

　　1998年11月9日

　　在一段作证录像中，当盖茨表示自己从未蓄意将竞争对手赶出软件市场时，他的身子微微颤抖。医生据此认为盖茨可能患有亚斯伯格症候群(Asperger's syndrome)。

　　1999年

　　盖茨和妻子将威廉·盖茨基金会更名为比尔与梅琳达·盖茨基金会，并提出了减少世界上不公平现象的目标。

　　21世纪初

　　2000年1月13日

　　盖茨辞去微软CEO一职，成为公司首席软件工程师，将大权交给鲍尔默。

　　2000年6月7日

　　美国联邦地区法院法官托马斯·潘菲尔德·杰克逊(Thomas Penfield Jackson)裁定微软应一分为二。

　　2000年11月

　　盖茨第三次登上《连线》杂志封面，这次是为了揭开微软反垄断案后鲜为人知的故事。

　　2001年6月28日

　　美国哥伦比亚地区上诉法院推翻杰克逊法官的裁决。

　　2002年

　　据针对中国内地和香港年轻人的调查显示，盖茨取代了毛泽东在他们心中的偶像地位。

　　2005年3月2日

　　盖茨在白金汉宫接受英国女王授予的骑士勋章，此前，鲁迪·朱利安尼和斯蒂文·斯皮尔伯格都曾获得这一殊荣。盖茨此后有资格在名字后面加上字母“KBE”(英帝国爵级勋章)。

　　2005年12月

　　盖茨夫妇和爱尔兰U2乐队主唱波诺当选为美国《时代》周刊2005年度人物。

　　2006年6月15日

　　盖茨宣布，他将在两年内逐步退出公司的日常事务管理。

　　2006年6月26日

　　在得到巴菲特300多亿美元捐款后，比尔与梅琳达·盖茨基金会规模壮大一倍，成为世界最大的慈善基金会。

　　2008年3月

　　《福布斯》发布08年全球富豪排行榜，蝉联13年首富桂冠的盖茨以580亿美元的资产总值下滑至第三的位置。而盖茨的牌友、“股神”巴菲特则取代他问鼎冠军宝座。(杨琳)

转自：http://www.cnblogs.com/lyj/archive/2007/01/09/616053.html

一、从控制台读取东西代码片断：
using System;

class TestReadConsole
{
    public static void Main()
    {
        Console.Write(Enter your name:);
        string strName = Console.ReadLine();
        Console.WriteLine( Hi + strName);
    }
}
二、读文件代码片断：
using System;
using System.IO;

public class TestReadFile
{
    public static void Main(String[] args)
    {
        // Read text file C:\temp\test.txt
        FileStream fs = new FileStream(@c:\temp\test.txt , FileMode.Open, FileAccess.Read);
        StreamReader sr = new StreamReader(fs); 
       
        String line=sr.ReadLine();
        while (line!=null)
        {
            Console.WriteLine(line);
            line=sr.ReadLine();
        }  
       
        sr.Close();
        fs.Close();
    }
}
三、写文件代码：
using System;
using System.IO;

public class TestWriteFile
{
    public static void Main(String[] args)
    {
        // Create a text file C:\temp\test.txt
        FileStream fs = new FileStream(@c:\temp\test.txt , FileMode.OpenOrCreate, FileAccess.Write);
        StreamWriter sw = new StreamWriter(fs);
        // Write to the file using StreamWriter class
        sw.BaseStream.Seek(0, SeekOrigin.End);
        sw.WriteLine( First Line );
        sw.WriteLine( Second Line);
        sw.Flush();
    }
}
四、拷贝文件：
using System;
using System.IO;

class TestCopyFile
{
    public static void Main()
    {
        File.Copy(c:\\temp\\source.txt, C:\\temp\\dest.txt ); 
    }
}
五、移动文件：
using System;
using System.IO;

class TestMoveFile
{
    public static void Main()
    {
        File.Move(c:\\temp\\abc.txt, C:\\temp\\def.txt ); 
    }
}
六、使用计时器：
using System;
using System.Timers;

class TestTimer
{
    public static void Main()
    {
        Timer timer = new Timer();
        timer.Elapsed += new ElapsedEventHandler( DisplayTimeEvent );
        timer.Interval = 1000;
        timer.Start();
        timer.Enabled = true;

        while ( Console.Read() != 'q' )
        {
             //-------------
        }
    }
    public static void DisplayTimeEvent( object source, ElapsedEventArgs e )
    {
        Console.Write(\r{0}, DateTime.Now);
    }
}
七、调用外部程序：
class Test
{
    static void Main(string[] args)
    {
        System.Diagnostics.Process.Start(notepad.exe);
    }
}

ADO.NET方面的：
八、连接Access数据库：
using System;
using System.Data;
using System.Data.OleDb;

class TestADO
{
    static void Main(string[] args)
    {
        string strDSN = Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\\test.mdb;
        string strSQL = SELECT * FROM employees ;

        OleDbConnection conn = new OleDbConnection(strDSN);
        OleDbCommand cmd = new OleDbCommand( strSQL, conn );
        OleDbDataReader reader = null;
        try
        {
            conn.Open();
            reader = cmd.ExecuteReader();
            while (reader.Read() )
            {
                Console.WriteLine(First Name:{0}, Last Name:{1}, reader[FirstName], reader[LastName]);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            conn.Close();
        }
    }
}
九、连接SQL Server数据库：
using System;
using System.Data.SqlClient;

public class TestADO
{
    public static void Main()
    {
        SqlConnection conn = new SqlConnection(Data Source=localhost; Integrated Security=SSPI; Initial Catalog=pubs);
        SqlCommand  cmd = new SqlCommand(SELECT * FROM employees, conn);
        try
        {       
            conn.Open();

            SqlDataReader reader = cmd.ExecuteReader();           
            while (reader.Read())
            {
                Console.WriteLine(First Name: {0}, Last Name: {1}, reader.GetString(0), reader.GetString(1));
            }
       
            reader.Close();
            conn.Close();
        }
        catch(Exception e)
        {
            Console.WriteLine(Exception Occured -->> {0},e);
        }       
    }
}
十、从SQL内读数据到XML：
using System;
using System.Data;
using System.Xml;
using System.Data.SqlClient;
using System.IO;

public class TestWriteXML
{
    public static void Main()
    {

        String strFileName=c:/temp/output.xml;

        SqlConnection conn = new SqlConnection(server=localhost;uid=sa;pwd=;database=db);

        String strSql = SELECT FirstName, LastName FROM employees;

        SqlDataAdapter adapter = new SqlDataAdapter();

        adapter.SelectCommand = new SqlCommand(strSql,conn);

        // Build the DataSet
        DataSet ds = new DataSet();

        adapter.Fill(ds, employees);

        // Get a FileStream object
        FileStream fs = new FileStream(strFileName,FileMode.OpenOrCreate,FileAccess.Write);

        // Apply the WriteXml method to write an XML document
        ds.WriteXml(fs);

        fs.Close();

    }
}
十一、用ADO添加数据到数据库中：
using System;
using System.Data;  
using System.Data.OleDb;  

class TestADO
{ 
    static void Main(string[] args) 
    { 
        string strDSN = Provider=Microsoft.Jet.OLEDB.4.0;DataSource=c:\test.mdb; 
        string strSQL = INSERT INTO Employee(FirstName, LastName) VALUES('FirstName', 'LastName') ; 
                  
        // create Objects of ADOConnection and ADOCommand  
        OleDbConnection conn = new OleDbConnection(strDSN); 
        OleDbCommand cmd = new OleDbCommand( strSQL, conn ); 
        try 
        { 
            conn.Open(); 
            cmd.ExecuteNonQuery(); 
        } 
        catch (Exception e) 
        { 
            Console.WriteLine(Oooops. I did it again:\n{0}, e.Message); 
        } 
        finally 
        { 
            conn.Close(); 
        }         
    }
} 
十二、使用OLEConn连接数据库：
using System;
using System.Data;  
using System.Data.OleDb;  

class TestADO
{ 
    static void Main(string[] args) 
    { 
        string strDSN = Provider=Microsoft.Jet.OLEDB.4.0;DataSource=c:\test.mdb; 
        string strSQL = SELECT * FROM employee ; 

        OleDbConnection conn = new OleDbConnection(strDSN);
        OleDbDataAdapter cmd = new OleDbDataAdapter( strSQL, conn );

        conn.Open();
        DataSet ds = new DataSet();
        cmd.Fill( ds, employee );
        DataTable dt = ds.Tables[0];

        foreach( DataRow dr in dt.Rows )
        {
            Console.WriteLine(First name: + dr[FirstName].ToString() + Last name: + dr[LastName].ToString());
        }
        conn.Close(); 
    }
} 
十三、读取表的属性：
using System;
using System.Data;  
using System.Data.OleDb;  

class TestADO
{ 
    static void Main(string[] args) 
    { 
        string strDSN = Provider=Microsoft.Jet.OLEDB.4.0;DataSource=c:\test.mdb; 
        string strSQL = SELECT * FROM employee ; 

        OleDbConnection conn = new OleDbConnection(strDSN);
        OleDbDataAdapter cmd = new OleDbDataAdapter( strSQL, conn );

        conn.Open();
        DataSet ds = new DataSet();
        cmd.Fill( ds, employee );
        DataTable dt = ds.Tables[0];

        Console.WriteLine(Field Name DataType Unique AutoIncrement AllowNull);
        Console.WriteLine(==================================================================);
        foreach( DataColumn dc in dt.Columns )
        {
            Console.WriteLine(dc.ColumnName+ , +dc.DataType + ,+dc.Unique + ,+dc.AutoIncrement+ ,+dc.AllowDBNull );
        }
        conn.Close(); 
    }
}

ASP.NET方面的
十四、一个ASP.NET程序：
<%@ Page Language=C# %>
<script runat=server>
  
    void Button1_Click(Object sender, EventArgs e)
    {
        Label1.Text=TextBox1.Text;
    }

</script>
<html>
<head>
</head>
<body>
    <form runat=server>
        <p>
            <br />
            Enter your name: <asp:TextBox id=TextBox1 runat=server></asp:TextBox>
        </p>
        <p>
            <b><asp:Label id=Label1 runat=server Width=247px></asp:Label></b>
        </p>
        <p>
            <asp:Button id=Button1 onclick=Button1_Click runat=server Text=Submit></asp:Button>
        </p>
    </form>
</body>
</html>

WinForm开发：
十五、一个简单的WinForm程序：
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

public class SimpleForm : System.Windows.Forms.Form
{

    private System.ComponentModel.Container components = null;
    private System.Windows.Forms.Button button1;
    private System.Windows.Forms.TextBox textBox1;
    public SimpleForm()
    {
        InitializeComponent();
    }

    protected override void Dispose( bool disposing )
    {
        if( disposing )
        {
            if (components != null)
            {
                components.Dispose();
            }
        }
        base.Dispose( disposing );
    }

    #region Windows Form Designer generated code
    private void InitializeComponent()
    {

        this.components = new System.ComponentModel.Container();
        this.Size = new System.Drawing.Size(300,300);
        this.Text = Form1;

        this.button1 = new System.Windows.Forms.Button();
        this.textBox1 = new System.Windows.Forms.TextBox();
        this.SuspendLayout();
    //
    // button1
    //

    this.button1.Location = new System.Drawing.Point(8, 16);
    this.button1.Name = button1;
    this.button1.Size = new System.Drawing.Size(80, 24);
    this.button1.TabIndex = 0;
    this.button1.Text = button1;

    //
    // textBox1
    //
    this.textBox1.Location = new System.Drawing.Point(112, 16);
    this.textBox1.Name = textBox1;
    this.textBox1.Size = new System.Drawing.Size(160, 20);
    this.textBox1.TabIndex = 1;
    this.textBox1.Text = textBox1;
    //
    // Form1
    //

    this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
    this.ClientSize = new System.Drawing.Size(292, 273);
    this.Controls.AddRange(new System.Windows.Forms.Control[] {
    this.textBox1,
    this.button1});
    this.Name = Form1;
    this.Text = Form1;
    this.ResumeLayout(false);

    }
    #endregion

    [STAThread]
    static void Main()
    {
        Application.Run(new SimpleForm());
    }
}
十六、运行时显示自己定义的图标：
//load icon and set to form
System.Drawing.Icon ico = new System.Drawing.Icon(@c:\temp\app.ico);
this.Icon = ico;
十七、添加组件到ListBox中：
private void Form1_Load(object sender, System.EventArgs e)
{
    string str = First item;
    int i = 23;
    float flt = 34.98f;
    listBox1.Items.Add(str);
    listBox1.Items.Add(i.ToString());
    listBox1.Items.Add(flt.ToString());
    listBox1.Items.Add(Last Item in the List Box);
}

网络方面的：
十八、取得IP地址：
using System;
using System.Net;

class GetIP
{
     public static void Main()
     {
         IPHostEntry ipEntry = Dns.GetHostByName (localhost);
         IPAddress [] IpAddr = ipEntry.AddressList;
         for (int i = 0; i < IpAddr.Length; i++)
         {
             Console.WriteLine (IP Address {0}: {1} , i, IpAddr.ToString ());
         }
    }
}
十九、取得机器名称：
using System;
using System.Net;

class GetIP
{
    public static void Main()
    {
          Console.WriteLine (Host name : {0}, Dns.GetHostName());
    }
}
二十、发送邮件：
using System;
using System.Web;
using System.Web.Mail;

public class TestSendMail
{
    public static void Main()
    {
        try
        {
            // Construct a new mail message
            MailMessage message = new MailMessage();
            message.From = from@domain.com;
            message.To   =  pengyun@cobainsoft.com;
            message.Cc   = ;
            message.Bcc  = ;
            message.Subject = Subject;
            message.Body = Content of message;
           
            //if you want attach file with this mail, add the line below
            message.Attachments.Add(new MailAttachment(c:\\attach.txt, MailEncoding.Base64));
 
            // Send the message
            SmtpMail.Send(message); 
            System.Console.WriteLine(Message has been sent);
        }

        catch(Exception ex)
        {
            System.Console.WriteLine(ex.Message.ToString());
        }

    }
}
二十一、根据IP地址得出机器名称：
using System;
using System.Net;

class ResolveIP
{
     public static void Main()
     {
         IPHostEntry ipEntry = Dns.Resolve(172.29.9.9);
         Console.WriteLine (Host name : {0}, ipEntry.HostName);        
     }
}

GDI+方面的：
二十二、GDI+入门介绍：
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

public class Form1 : System.Windows.Forms.Form
{
    private System.ComponentModel.Container components = null;

    public Form1()
    {
        InitializeComponent();
    }

    protected override void Dispose( bool disposing )
    {
        if( disposing )
        {
            if (components != null)
            {
                components.Dispose();
            }
        }
        base.Dispose( disposing );
    }

    #region Windows Form Designer generated code
    private void InitializeComponent()
    {
        this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
        this.ClientSize = new System.Drawing.Size(292, 273);
        this.Name = Form1;
        this.Text = Form1;
        this.Paint += new System.Windows.Forms.PaintEventHandler(this.Form1_Paint);
    }
    #endregion

    [STAThread]
    static void Main()
    {
        Application.Run(new Form1());
    }

    private void Form1_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
    {
        Graphics g=e.Graphics;
        g.DrawLine(new Pen(Color.Blue),10,10,210,110);
        g.DrawRectangle(new Pen(Color.Red),10,10,200,100);
        g.DrawEllipse(new Pen(Color.Yellow),10,150,200,100);
    }
}

XML方面的：
二十三、读取XML文件：
using System;
using System.Xml; 

class TestReadXML
{
    public static void Main()
    {
       
        XmlTextReader reader  = new XmlTextReader(C:\\test.xml);
        reader.Read();
       
        while (reader.Read())
        {           
            reader.MoveToElement();
            Console.WriteLine(XmlTextReader Properties Test);
            Console.WriteLine(===================); 

            // Read this properties of element and display them on console
            Console.WriteLine(Name: + reader.Name);
            Console.WriteLine(Base URI: + reader.BaseURI);
            Console.WriteLine(Local Name: + reader.LocalName);
            Console.WriteLine(Attribute Count: + reader.AttributeCount.ToString());
            Console.WriteLine(Depth: + reader.Depth.ToString());
            Console.WriteLine(Line Number: + reader.LineNumber.ToString());
            Console.WriteLine(Node Type: + reader.NodeType.ToString());
            Console.WriteLine(Attribute Count: + reader.Value.ToString());
        }       
    }              
}
二十四、写XML文件：
using System;
using System.Xml;

public class TestWriteXMLFile
{
    public static int Main(string[] args)
    {
        try
        { 
            // Creates an XML file is not exist
            XmlTextWriter writer = new XmlTextWriter(C:\\temp\\xmltest.xml, null);
            // Starts a new document
            writer.WriteStartDocument();
            //Write comments
            writer.WriteComment(Commentss: XmlWriter Test Program);
            writer.WriteProcessingInstruction(Instruction,Person Record);
            // Add elements to the file
            writer.WriteStartElement(p, person, urn:person);
            writer.WriteStartElement(LastName,);
            writer.WriteString(Chand);
            writer.WriteEndElement();
            writer.WriteStartElement(FirstName,);
            writer.WriteString(Mahesh);
            writer.WriteEndElement();
            writer.WriteElementInt16(age,, 25);
            // Ends the document
            writer.WriteEndDocument();
        }
        catch (Exception e)
        { 
            Console.WriteLine (Exception: {0}, e.ToString());
        }
        return 0;
    }
}

Web Service方面的：
二十五、一个Web Service的小例子：
<% @WebService Language=C# Class=TestWS %>

using System.Web.Services;

public class TestWS : System.Web.Services.WebService
{
    [WebMethod()]
    public string StringFromWebService()
    {
        return This is a string from web service.;
    }
}

一 ACIS

3D ACIS® Modeler (ACIS)是Spatial公司开发的业界领先的3D造型引擎，在全球有14个行业（包括
CAD/CAM/CAE、建筑、动画、造船等）的数百家开发厂商使用这个产品。ACIS为全球一些非常著名的软件开发商和制造商提供了强大的3D造型功能，他们在此基础上创建出了具有创新性和高性能的应用程序。自2000年11月成为（达索）Dassault Systèmes的全资子公司后，Spatial公司更加贴近用户，新版本的3D ACIS®Modeler在产品性能以及稳定性等方面均有大幅度地提升，得到了越来越多用户的普遍称赞和认可。功能

ACIS采用开放的和面向对象的C++架构，拥有强大的3D造型能力。ACIS集成了线框、曲面和实体造型的功能，支持流形和非流形拓扑，具备非常丰富的几何运算集，因此非常适用于构建具有混合造型功能的3D应用程序。ACIS不仅具备非常完善的3D建模的基本功能，而且具有很强的灵活性，满足了不同应用程序开发的需要。

二HOOPS

HOOPS 3D Application Framework (HOOPS/3dAF)是由Tech Soft America公司开发并由Spatial再次销售的产
品，该产品为当今世界上领先的3D应用程序提供了核心的图形架构和图形功能，这些3D应用程序涉及CAD/CAM/CAE、
工程、可视化和仿真等领域。有了HOOPS/3dAF，用户就站在一个高起点上，能够快速和有效地开发和维护高性能的用户应用程序。用户通过将HOOPS/3dAF集成到相应的软件开发中，可以更好地管理开发成本、优化资源和缩短产品上市时间。

快速和灵活的开发

HOOPS/3dAF是一个成熟、健壮的应用程序框架，而且也在不断地进行更新以满足日益变化的软件市场需求。该组件包不仅拥有不寻常的图形功能，而且使用非常灵活，加速了应用程序的开发和产品上市。HOOPS/3dAF是一个可扩展的、模块化和开放的架构，提供了非常全面的应用程序开发接口（API）供用户选用或根据用户特定需求进行定制。另外，HOOPS/3dAF组件包还提供了基于可读源代码的示例应用程序，从而可以帮助用户加快开发速度。

多种平台支持和开发工具集

HOOPS/3dAF 工具包可以工作在多种平台上，不仅支持各种32位操作系统上，而且也可以允许在多种64位操作系统上工作。该工具包所支持的主要平台包括Windows、UNIX和Linux。HOOPS/3dAF和公共用户接口工具集可以创建桌面应用程序，或 根据用户要求做成一个ActiveX控件或多平台的网络浏览器的插件。HOOPS/3dAF组件包支持的编程语言包括Python、Java（对选定组件）、C、C++和FORTRAN等。

性能和高级功能

HOOPS/3dAF不仅仅可以加快产品上市，它还为应用程序的开发提供了高级的2D和3D图形功能。HOOPS/3dAF提供了对Unicode字体的全面支持、精确的矢量图硬拷贝、完善的选择算法和高级颜色插值能力等。该产品与几何造型引擎紧密集成，能够开发出具有丰富图形功能的3D造型应用程序序。HOOPS/3dAF具备大模型显示的能力，为此，即使对于非常复杂的模型数据，用户也可以实现实时渲染和便捷的人机交互。

HOOPS/3dAF的集成组件

HOOPS 3D Graphics System 是一个特色鲜明的场景图应用程序接口，封装了高度优化的数据结构和用于2D和3D图形数据的创建、编辑、存储、操作、查询和渲染的算法。

HOOPS MVO Class Library 是一系列独立于平台和GUI的C++类，这些类是构造一般3D应用程序功能（如模型的创建、显示、动画和操作等）的基础。

HOOPS Stream Toolkit 是一系列独立于平台和GUI的C++类，这些类使应用程序可以在基于本地网或Internet创建和流化处理高度压缩的数据文件（这些数据文件可以是2D、3D数据，也可以是用户自定义数据）。HOOPS Stream Toolkit组件既可以和HOOPS/3dAF一起使用，也可以单独使用。

HOOPS Graphical User Interface 是一系列连接不同GUI工具包的集成模块，可以连接以下GUI：

• Microsoft Foundation Classes (MFC) for Windows
• ActiveX and ATL Control Classes for Windows
• Netscape Plug-in Classes for Windows and UNIX
• Motif Toolkit for UNIX
• Qt Toolkit for cross-platform GUI development.

HOOPS Geometric Modeler Bridges 与几何造型引擎（如3D ACIS® Modeler）紧密集成，大大简化了基于实体和基于曲面的应用程序的开发。

HOOPS Reference Applications 以源代码的方式提供了丰富的例子，详细说明了HOOPS/3dAF的基本架构和使用方法，以及如何使用HOOPS/3dAF成功开发应用程序。

HOOPS 基本图元和属性支持 包括：

• 几何：Images, Unicode Text, Points, Lines, Polygons, Polylines, Polycylinders,NURBS curves, NURBS surfaces, Arcs, Ellipses, Circles, Tristrips, Trifans,Indexed Facesets, Cutting Planes, Capping Geometry
• 几何属性：Color, Transparency, Textures, Visibility, Patterns (Facet,edge 和 Line), Color Ramps, Lighting Interpolation, Selectability
• 渲染属性：Shaded, Analytic Hidden Line, Wireframe,Color Maps, Various Color Ramping Algorithms, Window Background Coloring

三 3D InterOp
      作为3D技术的领导者，Spatial意识到实现不同格式数据（包括原始格式数据和非原始格式数据）有效转换的必要性。为此，Spatial开发了3D InterOp数据转换组件，开发者们可以很容易地将我们提供的先进的3D数据转换技术集成到各自的3D软件产品中，这些软件产品可以是CAD/CAM/CAE应用程序、数据管理系统（如PDM、EDM和MES等）、协同系统以及可视化解决方案等

四 参考

http://www.techsoft3d.com/

http://www.spatial.com

http://www.spatial.com.cn

UML的类图关系分为： 关联、聚合/组合、依赖、泛化（继承）。而其中关联又分为双向关联、单向关联、自身关联；下面就让我们一起来看看这些关系究竟是什么，以及它们的区别在哪里。

1、关联


双向关联：
C1-C2：指双方都知道对方的存在，都可以调用对方的公共属性和方法。

在GOF的设计模式书上是这样描述的：虽然在分析阶段这种关系是适用的，但我们觉得它对于描述设计模式内的类关系来说显得太抽象了，因为在设计阶段关联关系必须被映射为对象引用或指针。对象引用本身就是有向的，更适合表达我们所讨论的那种关系。所以这种关系在设计的时候比较少用到，关联一般都是有向的。

使用ROSE 生成的代码是这样的：

class C1 
...{
public:
    C2* theC2;

};

class C2 
...{
public:
    C1* theC1;

};

双向关联在代码的表现为双方都拥有对方的一个指针，当然也可以是引用或者是值。





单向关联:
C3->C4：表示相识关系，指C3知道C4，C3可以调用C4的公共属性和方法。没有生命期的依赖。一般是表示为一种引用。

生成代码如下：

class C3 
...{
public:
    C4* theC4;

};

class C4 
...{

};

单向关联的代码就表现为C3有C4的指针，而C4对C3一无所知。

自身关联（反身关联）：
自己引用自己，带着一个自己的引用。

代码如下：

class C14 
...{
public:
    C14* theC14;

};

就是在自己的内部有着一个自身的引用。

2、聚合/组合

当类之间有整体-部分关系的时候，我们就可以使用组合或者聚合。



聚合：表示C9聚合C10，但是C10可以离开C9而独立存在（独立存在的意思是在某个应用的问题域中这个类的存在有意义。这句话怎么解，请看下面组合里的解释）。

代码如下：

class C9 
...{
public:
    C10 theC10;

};

class C10 
...{

};

组合（也有人称为包容）：一般是实心菱形加实线箭头表示，如上图所示，表示的是C8被C7包容，而且C8不能离开C7而独立存在。但这是视问题域而定的，例如在关心汽车的领域里，轮胎是一定要组合在汽车类中的，因为它离开了汽车就没有意义了。但是在卖轮胎的店铺业务里，就算轮胎离开了汽车，它也是有意义的，这就可以用聚合了。在《敏捷开发》中还说到，A组合B，则A需要知道B的生存周期，即可能A负责生成或者释放B，或者A通过某种途径知道B的生成和释放。

他们的代码如下：

class C7 
...{
public:
    C8 theC8;

};

class C8 
...{
};

可以看到，代码和聚合是一样的。具体如何区别，可能就只能用语义来区分了。

3、依赖



依赖:
指C5可能要用到C6的一些方法，也可以这样说，要完成C5里的所有功能，一定要有C6的方法协助才行。C5依赖于C6的定义，一般是在C5类的头文件中包含了C6的头文件。ROSE对依赖关系不产生属性。

注意，要避免双向依赖。一般来说，不应该存在双向依赖。

ROSE生成的代码如下：

// C5.h
#include "C6.h"

class C5 
...{

};

// C6.h
#include "C5.h"

class C6
...{

};

虽然ROSE不生成属性，但在形式上一般是A中的某个方法把B的对象作为参数使用(假设A依赖于B)。如下：

#include "B.h"
class A
...{
          void Func(B &b);
}

那依赖和聚合\组合、关联等有什么不同呢？

关联是类之间的一种关系，例如老师教学生，老公和老婆，水壶装水等就是一种关系。这种关系是非常明显的，在问题领域中通过分析直接就能得出。

依赖是一种弱关联，只要一个类用到另一个类，但是和另一个类的关系不是太明显的时候（可以说是“uses”了那个类），就可以把这种关系看成是依赖，依赖也可说是一种偶然的关系，而不是必然的关系，就是“我在某个方法中偶然用到了它，但在现实中我和它并没多大关系”。例如我和锤子，我和锤子本来是没关系的，但在有一次要钉钉子的时候，我用到了它，这就是一种依赖，依赖锤子完成钉钉子这件事情。

组合是一种整体-部分的关系，在问题域中这种关系很明显，直接分析就可以得出的。例如轮胎是车的一部分，树叶是树的一部分，手脚是身体的一部分这种的关系，非常明显的整体-部分关系。

上述的几种关系（关联、聚合/组合、依赖）在代码中可能以指针、引用、值等的方式在另一个类中出现，不拘于形式，但在逻辑上他们就有以上的区别。

这里还要说明一下，所谓的这些关系只是在某个问题域才有效，离开了这个问题域，可能这些关系就不成立了，例如可能在某个问题域中，我是一个木匠，需要拿着锤子去干活，可能整个问题的描述就是我拿着锤子怎么钉桌子，钉椅子，钉柜子；既然整个问题就是描述这个，我和锤子就不仅是偶然的依赖关系了，我和锤子的关系变得非常的紧密，可能就上升为组合关系（让我突然想起武侠小说的剑不离身，剑亡人亡...）。这个例子可能有点荒谬，但也是为了说明一个道理，就是关系和类一样，它们都是在一个问题领域中才成立的，离开了这个问题域，他们可能就不复存在了。


4、泛化（继承）



泛化关系：如果两个类存在泛化的关系时就使用，例如父和子，动物和老虎，植物和花等。
ROSE生成的代码很简单，如下：

#include "C11.h"

class C12 : public C11
...{
};

5、这里顺便提一下模板



上面的图对应的代码如下：

template<int>
class C13 
...{
};

这里再说一下重复度，其实看完了上面的描述之后，我们应该清楚了各个关系间的关系以及具体对应到代码是怎么样的，所谓的重复度，也只不过是上面的扩展，例如A和B有着“1对多”的重复度，那在A中就有一个列表，保存着B对象的N个引用，就是这样而已。

好了，到这里，已经把上面的类图关系说完了，希望你能有所收获了，我也费了不少工夫啊（画图、生成代码、截图、写到BLOG上，唉，一头大汗）。不过如果能让你彻底理解UML类图的这些关系，也值得了。:)

前言 

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。 

关于虚函数的使用方法，我在这里不做过多的阐述。大家可以看看相关的C++的书籍。在这篇文章中，我只想从虚函数的实现机制上面为大家 一个清晰的剖析。 

当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的代码，没有图片，没有详细的说明，没有比较，没有举一反三。不利于学习和阅读，所以这是我想写下这篇文章的原因。也希望大家多给我提意见。 

言归正传，让我们一起进入虚函数的世界。 

虚函数表 

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、重载的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。 

这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。 

听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。 没关系，下面就是实际的例子，相信聪明的你一看就明白了。 

假设我们有这样的一个类：

class Base {

     public:

            virtual void f() { cout << "Base::f" << endl; }

            virtual void g() { cout << "Base::g" << endl; }

            virtual void h() { cout << "Base::h" << endl; } 

};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。 下面是实际例程：

            typedef void(*Fun)(void); 

            Base b; 

            Fun pFun = NULL; 

            cout << "虚函数表地址：" << (int*)(&b) << endl;

            cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;
 

            // Invoke the first virtual function 

            pFun = (Fun)*((int*)*(int*)(&b));

            pFun();

实际运行经果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虚函数表地址：0012FED4

虚函数表 — 第一个函数地址：0044F148

Base::f 

通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

            (Fun)*((int*)*(int*)(&b)+0); // Base::f()

            (Fun)*((int*)*(int*)(&b)+1); // Base::g()

            (Fun)*((int*)*(int*)(&b)+2); // Base::h()

这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

下面，我将分别说明“无重载”和“有重载”时的虚函数表的样子。没有重载父类的虚函数是毫无意义的。我之所以要讲述没有重载的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

一般继承（无虚函数重载）

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

我相信聪明的你一定可以参考前面的那个程序，来编写一段程序来验证。 

一般继承（有虚函数重载）

重载父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

为了让大家看到被继承过后的效果，在这个类的设计中，我只重载了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点，

1）重载的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被重载的函数依旧。

这样，我们就可以看到对于下面这样的程序，

            Base *b = new Derive();

            b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。 

多重继承（无虚函数重载） 

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有重载复类的函数。

对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：

1） 每个父类都有自己的虚表。

2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

多重继承（有虚函数重载）

下面我们再来看看，如果发生虚函数重载的情况。

下图中，我们重载了父类的f()函数。

下面是对于子类实例中的虚函数表的图：

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

            Derive d;

            Base1 *b1 = &d;

            Base2 *b2 = &d;

            Base3 *b3 = &d;

            b1->f(); //Derive::f()

            b2->f(); //Derive::f()

            b3->f(); //Derive::f()

            b1->g(); //Base1::g()

            b2->g(); //Base2::g()

            b3->g(); //Base3::g()

安全性 

每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。

一、通过父类型的指针访问子类自己的虚函数

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

          Base1 *b1 = new Derive();

            b1->f1(); //编译出错

任何妄图使用父类指针想调用子类中的未重载父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）

二、访问non-public的虚函数

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。

如：

class Base {

    private:

            virtual void f() { cout << "Base::f" << endl; }

};

class Derive : public Base{

};

typedef void(*Fun)(void);

void main() {

    Derive d;

    Fun pFun = (Fun)*((int*)*(int*)(&d)+0);

    pFun();

}

结束语

C++这门语言是一门Magic的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言，我们就必需要了解C++里面的那些东西，需要去了解C++中那些危险的东西。不然，这是一种搬起石头砸自己脚的编程语言。

在文章束之前还是介绍一下自己吧。我从事软件研发有十个年头了，目前是软件开发技术主管，技术方面，主攻Unix/C/C++，比较喜欢网络上的技术，比如分布式计算，网格计算，P2P，Ajax等一切和互联网相关的东西。管理方面比较擅长于团队建设，技术趋势分析，项目管理。欢迎大家和我交流，我的MSN和Email是：haoel@hotmail.com 

附录一：VC中查看虚函数表

我们可以在VC的IDE环境中的Debug状态下展开类的实例就可以看到虚函数表了（并不是很完整的）

附录 二：例程

下面是一个关于多重继承的虚函数表访问的例程：

#include <iostream>

using namespace std;

class Base1 {

public:

            virtual void f() { cout << "Base1::f" << endl; }

            virtual void g() { cout << "Base1::g" << endl; }

            virtual void h() { cout << "Base1::h" << endl; }

};

class Base2 {

public:

            virtual void f() { cout << "Base2::f" << endl; }

            virtual void g() { cout << "Base2::g" << endl; }

            virtual void h() { cout << "Base2::h" << endl; }

};

class Base3 {

public:

            virtual void f() { cout << "Base3::f" << endl; }

            virtual void g() { cout << "Base3::g" << endl; }

            virtual void h() { cout << "Base3::h" << endl; }

};

class Derive : public Base1, public Base2, public Base3 {

public:

            virtual void f() { cout << "Driver::f" << endl; }

            virtual void g1() { cout << "Driver::g1" << endl; }

};

typedef void(*Fun)(void);

int main()

{

            Fun pFun = NULL;

            Derive d;

            int** pVtab = (int**)&d;

            //Base1's vtable

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);

            pFun = (Fun)pVtab[0][0];

            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);

            pFun = (Fun)pVtab[0][1];

            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);

            pFun = (Fun)pVtab[0][2];

            pFun();

            //Derive's vtable

            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);

            pFun = (Fun)pVtab[0][3];

            pFun();

            //The tail of the vtable

            pFun = (Fun)pVtab[0][4];

            cout<<pFun<<endl;

            //Base2's vtable

            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);

            pFun = (Fun)pVtab[1][0];

            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);

            pFun = (Fun)pVtab[1][1];

            pFun();

            pFun = (Fun)pVtab[1][2];

            pFun();

            //The tail of the vtable

            pFun = (Fun)pVtab[1][3];

            cout<<pFun<<endl;

            //Base3's vtable

            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);

            pFun = (Fun)pVtab[2][0];

            pFun();

            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);

            pFun = (Fun)pVtab[2][1];

            pFun();

            pFun = (Fun)pVtab[2][2];

            pFun();

            //The tail of the vtable

            pFun = (Fun)pVtab[2][3];

            cout<<pFun<<endl;

            return 0;

}

(转载时请注明作者和出处。未经许可，请勿用于商业用途)

更多文章请访问我的Blog: http://blog.csdn.net/haoel

分析： 

#include <cstdlib>
#include <iostream>

using namespace std;
unsigned int foo(unsigned int *arr)
{
    unsigned int p[] ={1,2,6,24,120,720,5040,40320,362880};
    unsigned int i,j,c,s=p[8];//first the number is p^9₉
    for(i = 0; i < 7; i++)
       for(j = i+1; j < 8; j++)
       {
           if(arr[i]>arr[j])  //swap two number
           {
               arr[i]^=arr[j];
               arr[j]^=arr[i];
               arr[i]^=arr[j];
           }   
       }   
    i = 0;
    c = 0;
    while(i<8)
    {
        j = i+1;
        while(arr[i]==arr[j])//compute the number of the repetition 
        {
            c++;   
            j++; 
        }   
        s/=p[c];
        c=0;
        i=j;
    }   
    return s;
}
  
int main()
{
    unsigned int a[]={1,3,3,5,6,7,8,8,9};
    cout<<"The number of permutation is: "<<foo(a)<<endl;
    system("pause");
    return 0;
}    
还可以改进排序那部分。

转一个经典的题目：

给一个天平,问如何用3次把这个小球找出来
并且求出这个小球是比其他的轻还是重
将12个球分别编号为a1,a2,a3.......a10,a11,a12.
第一步：将12球分开3拨，每拨4个，a1~a4第一拨，记为b1， a5~a8第2拨，记为b2，其余第3拨，记为b3；
第二步：将b1和b2放到天平两盘上，记左盘为c1，右为c2；这时候分两中情况：

1.c1和c2平衡，此时可以确定从a1到a8都是常球；然后把c2拿空，并从c1上拿下a4，从a9到a12四球里随便取三球，假设为a9到a11，放到c2上。此时c1上是a1到a3，c2上是a9到a11。从这里又分三种情况：
     A：天平平衡，很简单，说明没有放上去的a12就是异球，而到此步一共称了两次，所以将a12随便跟11个常球再称一次，也就是第三次，马上就可以确定a12是重还是轻；
     B：若c1上升，则这次称说明异球为a9到a11三球中的一个，而且是比常球重。取下c1所有的球，并将a8放到c1上，将a9取下，比较a8和a11（第三次称），如果平衡则说明从c2上取下的a9是偏重异球，如果不平衡，则偏向哪盘则哪盘里放的就是偏重异球；
     C：若c1下降，说明a9到a11里有一个是偏轻异球。次种情况和B类似，所以接下来的步骤照搬B就是；

2.c1和c2不平衡，这时候又分两种情况，c1上升和c1下降，但是不管哪种情况都能说明a9到a12是常球。这步是解题的关键。也是这个题最妙的地方。
     A：c1上升，此时不能判断异球在哪盘也不能判断是轻还是重。取下c1中的a2到a4三球放一边，将c2中的a5和a6放到c1上，然后将常球a9放到c2上。至此，c1上是a1，a5和a6，c2上是a7，a8和a9。此时又分三中情况：
         1）如果平衡，说明天平上所有的球都是常球，异球在从c1上取下a2到a4中。而且可以断定异球轻重。因为a5到a8都是常球，而第2次称的时候c1是上升的，所以a2到a4里必然有一个轻球。那么第三次称就用来从a2到a4中找到轻球。这很简单，随便拿两球放到c1和c2，平衡则剩余的为要找球，不平衡则哪边低则哪个为要找球；
         2）c1仍然保持上升，则说明要么a1是要找的轻球，要么a7和a8两球中有一个是重球（这步懂吧？好好想想，很简单的。因为a9是常球，而取下的a2到a4肯定也是常球，还可以推出换盘放置的a5和a6也是常球。所以要么a1轻，要么a7或a8重）。至此，还剩一次称的机会。只需把a7和a8放上两盘，平衡则说明a1是要找的偏轻异球，如果不平衡，则哪边高说明哪个是偏重异球；
         3）如果换球称第2次后天平平衡打破，并且c1降低了，这说明异球肯定在换过来的a5和a6两求中，并且异球偏重，否则天平要么平衡要么保持c1上升。确定要找球是偏重之后，将a5和a6放到两盘上称第3次根据哪边高可以判定a5和a6哪个是重球；
     B：第1次称后c1是下降的，此时可以将c1看成c2，其实以后的步骤都同A，所以就不必要再重复叙述了。至此，不管情况如何，用且只用三次就能称出12个外观手感一模一样的小球中有质量不同于其他11球的偏常的球。而且在称的过程中可以判定其是偏轻还是偏重。

3.U2 合唱团在17 分钟内得赶到演唱会场，途中必需跨过一座桥，四个人从桥的同一端出发，你得帮助他们到达另一端，天色很暗，而他们只有一只手电筒。一次同时最多可以有两人一起过桥，而过桥的时候必须持有手电筒，所以就得有人把手电筒带来带去，来回桥两端。手电筒是不能用丢的方式来传递的。四个人的步行速度各不同，若两人同行则以较慢者的速度为准。Bono 需花1 分钟过桥，Edge 需花2 分钟过桥，Adam需花 5 分钟过桥，Larry 需花10 分钟过桥。他们要如何在17 分钟内过桥呢？（有个同济的学生写文章说他当时在微软面试时就是碰到了这道题，最短只能做出在19分钟内过桥，微软的人对他讲这样的结果已经是不错的了！） 
  A点到 B 点
 1 和2 过去 2 分钟 2 
 2 过来 4 分钟 2+2=4
10和 5过去 14 分钟 4+10=14  
1 过来 15 分钟 14+1=15  
1 和2 过去 17 分钟 15+2=17

第一组  
　　1.烧一根不均匀的绳，从头烧到尾总共需要1个小时。现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个小时十五分钟呢?
       ans:三根绳，开始的时候，第一根点燃两端，第二根点燃一端，第三根不点。第一根绳烧完(30分钟)后，点燃第二根绳的另一端，第二根只要15分钟就可以烧完了，第二根绳烧完(45分钟)后，点燃第三根绳子两端，第三根绳烧完(1小时15分)后，计时完成

　　2.你有一桶果冻，其中有黄色、绿色、红色三种，闭上眼睛抓取同种颜色的两个。抓取多少个就可以确定你肯定有两个同一颜色的果冻?

　　3.如果你有无穷多的水，一个3公升的提捅，一个5公升的提捅，两只提捅形状上下都不均匀，问你如何才能准确称出4公升的水?

　　4.一个岔路口分别通向诚实国和说谎国。来了两个人，已知一个是诚实国的，另一个是说谎国的。诚实国永远说实话，说谎国永远说谎话。现在你要去说谎国，但不知道应该走哪条路，需要问这两个人。请问应该怎么问?

　　5.12个球一个天平，现知道只有一个和其它的重量不同，问怎样称才能用三次就找到那个球。13个呢?(注意此题并未说明那个球的重量是轻是重，所以需要仔细考虑)

　　6.在9个点上画10条直线，要求每条直线上至少有三个点?

　　7.在一天的24小时之中，时钟的时针、分针和秒针完全重合在一起的时候有几次?都分别是什么时间?你怎样算出来的?

　　8.怎么样种植4棵树木，使其中任意两棵树的距离相等?

　　第二组  

　　1.为什么下水道的盖子是圆的?

　　2.中国有多少辆汽车?

　　3.将汽车钥匙插入车门，向哪个方向旋转就可以打开车锁?

　　4.如果你要去掉中国的34个省(含自治区、直辖市和港澳特区及台湾省)中的任何一个，你会去掉哪一个，为什么?

　　5.多少个加油站才能满足中国的所有汽车?

　　6.想象你站在镜子前，请问，为什么镜子中的影象可以颠倒左右，却不能颠倒上下?

　　7.为什么在任何旅馆里，你打开热水，热水都会瞬间倾泻而出?

　　8.你怎样将Excel的用法解释给你的奶奶听?

　　9.你怎样重新改进和设计一个ATM银行自动取款机?

　　10.如果你不得不重新学习一种新的计算机语言，你打算怎样着手来开始?

　　11.如果你的生涯规划中打算在5年内受到奖励，那获取该项奖励的动机是什么?观众是谁?

　　12.如果微软告诉你，我们打算投资五百万美元来启动你的投资计划，你将开始什么样商业计划?为什么?

　　13.如果你能够将全世界的电脑厂商集合在一个办公室里，然后告诉他们将被强迫做一件事，那件事将是什么?　

 

第三组  

　　1.你让工人为你工作7天，回报是一根金条，这个金条平分成相连的7段，你必须在每天结束的时候给他们一段金条。如果只允许你两次把金条弄断，你如何给你的工人付费?

　　2.有一辆火车以每小时15公里的速度离开北京直奔广州，同时另一辆火车每小时20公里的速度从广州开往北京。如果有一只鸟，以30公里每小时的速度和两辆火车同时启动，从北京出发，碰到另一辆车后就向相反的方向返回去飞，就这样依次在两辆火车之间来回地飞，直到两辆火车相遇。请问，这只鸟共飞行了多长的距离?

　　3.你有四个装药丸的罐子，每个药丸都有一定的重量，被污染的药丸是没被污染的药丸的重量+1。只称量一次，如何判断哪个罐子的药被污染了?

　　4.门外三个开关分别对应室内三盏灯，线路良好，在门外控制开关时候不能看到室内灯的情况，现在只允许进门一次，确定开关和灯的对应关系?

　　5.人民币为什么只有1、2、5、10的面值?

　　6.你有两个罐子以及50个红色弹球和50个蓝色弹球，随机选出一个罐子， 随机选出一个弹球放入罐子，怎么给出红色弹球最大的选中机会?在你的计划里，得到红球的几率是多少?

　　7.给你两颗6面色子，可以在它们各个面上刻上0-9任意一个数字，要求能够用它们拼出任意一年中的日期数值

　　第四组 

　　第一题 . 五个海盗抢到了100颗宝石，每一颗都一样大小和价值连城。他们决定这么分：

　　抽签决定自己的号码(1、2、3、4、5)

　　首先，由1号提出分配方案，然后大家表决，当且仅当超过半数的人同意时，按照他的方案

　　进行分配，否则将被扔进大海喂鲨鱼

　　如果1号死后，再由2号提出分配方案，然后剩下的4人进行表决，当且仅当超过半数的人同

　　意时，按照他的方案进行分配，否则将被扔入大海喂鲨鱼

　　依此类推

　　条件：每个海盗都是很聪明的人，都能很理智地做出判断，从而做出选择。

　　问题：第一个海盗提出怎样的分配方案才能使自己的收益最大化?

　　第二题 . 一道关于飞机加油的问题，已知：

　　每个飞机只有一个油箱，

　　飞机之间可以相互加油(注意是相互，没有加油机)

　　一箱油可供一架飞机绕地球飞半圈，

　　问题：

　　为使至少一架飞机绕地球一圈回到起飞时的飞机场，至少需要出动几架飞机?(所有飞机从同一机场起飞，而且必须安全返回机场，不允许中途降落，中间没有飞机场)第三题. 汽车加油问题  

　　一辆载油500升的汽车从A开往1000公里外的B，已知汽车每公里耗油量为1升，A处有无穷多的油，其他任何地点都没有油，但该车可以在任何地点存放油以备中转，问从A到B最少需要多少油

　　第四题. 掷杯问题

　　一种杯子，若在第N层被摔破，则在任何比N高的楼层均会破，若在第M层不破，则在任何比M低的楼层均会破，给你两个这样的杯子，让你在100层高的楼层中测试，要求用最少的测试次数找出恰巧会使杯子破碎的楼层。

　　第五题. 推理游戏

　　教授选出两个从2到9的数，把它们的和告诉学生甲，把它们的积告诉学生乙，让他们轮流猜这两个数

　　甲说：“我猜不出”

　　乙说：“我猜不出”

　　甲说：“我猜到了”

　　乙说：“我也猜到了”

　　问这两个数是多少

　　第六题. 病狗问题

　　一个住宅区内有100户人家，每户人家养一条狗，每天傍晚大家都在同一个地方遛狗。已知这些狗中有一部分病狗，由于某种原因，狗的主人无法判断自己的狗是否是病狗，却能够分辨其他的狗是否有病，现在，上级传来通知，要求住户处决这些病狗，并且不允许指认他人的狗是病狗(就是只能判断自己的)，过了7天之后，所有的病狗都被处决了，问，一共有几只病狗?为什么?

　　第八题. 监狱里有100个房间，每个房间内有一囚犯。一天，监狱长说，你们狱房外有一电灯，你们在放风时可以控制这个电灯(熄或亮)。每天只能有一个人出来放风，并且防风是随机的。如果在有限时间内，你们中的某人能对我说：“我敢保证，现在每个人都已经至少放过一次风了。”我就放了你们!问囚犯们要采取什么策略才能被监狱长放掉?如果采用了这种策略，大致多久他们可以被释放?

 

第五组  

　　1.某手机厂家由于设计失误，有可能造成电池寿命比原来设计的寿命短一半(不是冲放电时间)，解决方案就是免费更换电池或给50元购买该厂家新手机的折换券。请给所有已购买的用户写信告诉解决方案。

　　2.一高层领导在参观某博物馆时，向博物馆馆员小王要了一块明代的城砖作为纪念，按国家规定，任何人不得将博物馆收藏品变为私有。博物馆馆长需要如何写信给这位领导，将城砖取回。

　　3.营业员小姐由于工作失误，将2万元的笔记本电脑以1.2万元错卖给李先生，王小姐的经理怎么写信给李先生试图将钱要回来?

　　4.给你一款新研制的手机，如果你是测试组的组长，你会如何测试?

　　5.如何为函数int atoi(const char * pstr)编写测试向量?

　　第六组  

　　1.链表和数组的区别在哪里?

　　2.编写实现链表排序的一种算法。说明为什么你会选择用这样的方法?

　　3.编写实现数组排序的一种算法。说明为什么你会选择用这样的方法?

　　4.请编写能直接实现char * strcpy(char * pstrDest,const char * pstrSource)函数功能的代码。

　　5.编写反转字符串的程序，要求优化速度、优化空间。

　　6.在链表里如何发现循环链接?

　　7.给出洗牌的一个算法，并将洗好的牌存储在一个整形数组里。

　　8.写一个函数，检查字符是否是整数，如果是，返回其整数值。(或者：怎样只用4行代码

　　9.给出一个函数来输出一个字符串的所有排列。

　　10.请编写实现void * malloc(int)内存分配函数功能一样的代码。

　　11.给出一个函数来复制两个字符串A和B。字符串A的后几个字节和字符串B的前几个字节重叠。

　　12.怎样编写一个程序，把一个有序整数数组放到二叉树中?

　　13.怎样从顶部开始逐层打印二叉树结点数据?请编程。

　　14.怎样把一个链表掉个顺序(也就是反序，注意链表的边界条件并考虑空链表)? --

　　15.请编写能直接实现int atoi(const char * pstr)函数功能的代码

-----------------------------------------------------------------------------------
第一组题答案： 

　　
　　2)根据抽屉原理，4个

　　3)3升装满;3升-〉5升(全注入);3升装满;3升-〉5升(剩1升);5升倒掉;3升-〉5升(注入1升);3升装满;3升-〉5升;完成(另：可用回溯法编程求解)

　　4)问其中一人：另外一个人会说哪一条路是通往诚实国的?回答者所指的那条路必然是通往说谎国的。

　　5)12个球：

　　第一次：4，4 如果平了：

　　那么剩下的球中取3放左边,取3个好球放右边，称：

　　如果左边重，那么取两个球称一下，哪个重哪个是次品，平的话第三个重，是次品，轻的话同理

　　如果平了，那么剩下一个次品，还可根据需要称出次品比正品轻或者重

　　如果不平：

　　那么不妨设左边重右边轻，为了便于说明，将左边4颗称为重球，右边4颗称为轻球，剩下4颗称为好球

　　取重球2颗，轻球2颗放在左侧，右侧放3颗好球和一颗轻球

　　如果左边重

　　称那两颗重球，重的一个次品，平的话右边轻球次品

　　如果右边重

　　称左边两颗轻球，轻的一个次品

　　如果平

　　称剩下两颗重球，重的一个次品，平的话剩下那颗轻球次品

　　13个球：

　　第一次：4，4，如果平了

　　剩5颗球用上面的方法仍旧能找出次品，只是不能知道次品是重是轻

　　如果不平，同上　

6)  

　　o o o

　　o o o

　　o o o

　　7)

　　23次，因为分针要转24圈，时针才能转1圈，而分针和时针重合两次之间的间隔显然>1小时，它们有23次重合机会，每次重合中秒针有一次重合机会，所以是23次

　　重合时间可以对照手表求出，也可列方程求出

　　8)

　　在地球表面种树，做一个地球内接的正四面体，内接点即为所求

　　第二组 无标准答案  

　　第三组 

　　1. 分成1,2,4三段，第一天给1，第二天给2取回1，第3天给1，第4天给4取回1、2，第5天给1，第6天给2取回1，第七天给1

　　2. 求出火车相遇时间，鸟速乘以时间就是鸟飞行的距离

　　3. 四个罐子中分别取1,2,3,4颗药丸，称出比正常重多少，即可判断出那个罐子的药被污染

　　4. 三个开关分别：关，开，开10分钟，然后进屋，暗且凉的为开关1控制的灯，亮的为开关2控制的灯，暗且热的为开关3控制的灯

　　5. 因为可以用1，2，5，10组合成任何需要的货币值，日常习惯为10进制

　　6. 题意不理解...*_*

　　7. 012345 0126(9)78

　　第四组 都是很难的题目  

　　第一题：97 0 1 2 0 或者 97 0 1 0 2 (提示：可用逆推法求出)

　　第二题：3架飞机5架次，飞法：

　　ABC 3架同时起飞，1/8处，C给AB加满油，C返航，1/4处，B给A加满油，B返航，A到达1/2处，C从机场往另一方向起飞，3/4处，C同已经空油箱的A平分剩余油量，同时B从机场起飞，AC到7/8处同B平分剩余油量，刚好3架飞机同时返航。所以是3架飞机5架次。第三题：需要建立数学模型  

　　(提示，严格证明该模型最优比较麻烦，但确实可证，大胆猜想是解题关键)

　　题目可归结为求数列 an=500/(2n+1) n=0,1,2,3......的和Sn什么时候大于等于1000,解得n>6

　　当n=6时，S6=977.57

　　所以第一个中转点离起始位置距离为1000-977.57=22.43公里

　　所以第一次中转之前共耗油 22.43*(2*7+1)=336.50升

　　此后每次中转耗油500升

　　所以总耗油量为7*500+336.50=3836.50升

　　第四题：需要建立数学模型

　　题目可归结为求自然数列的和S什么时候大于等于100，解得n>13

　　第一个杯子可能的投掷楼层分别为：14，27，39，50，60，69，77，84，90，95，99，100

　　第五题：3和4(可严格证明)

　　设两个数为n1，n2，n1>=n2，甲听到的数为n=n1+n2，乙听到的数为m=n1*n2

　　证明n1=3，n2=4是唯一解

　　证明：要证以上命题为真，不妨先证n=7

　　1)必要性：

　　i) n>5 是显然的，因为n<4不可能，n=4或者n=5甲都不可能回答不知道

　　ii) n>6 因为如果n=6的话，那么甲虽然不知道(不确定2+4还是3+3)但是无论是2，4还是3，3乙都不可能说不知道(m=8或者m=9的话乙说不知道是没有道理的)

　　iii) n<8 因为如果n>=8的话，就可以将n分解成 n=4+x 和 n=6+(x-2)，那么m可以是4x也可以是6(x-2)而4x=6(x-2)的必要条件是x=6即n=10，那样n又可以分解成8+2，所以总之当n>=8时，n至少可以分解成两种不同的合数之和，这样乙说不知道的时候，甲就没有理由马上说知道。

　　以上证明了必要性

　　2)充分性

　　当n=7时，n可以分解成2+5或3+4

　　显然2+5不符合题意，舍去，容易判断出3+4符合题意，m=12，证毕

　　于是得到n=7 m=12 n1=3 n2=4是唯一解。第六题：7只(数学归纳法证明)  

　　1)若只有1只病狗，因为病狗主人看不到有其他病狗，必然会知道自己的狗是病狗(前提是一定存在病狗)，所以他会在第一天把病狗处决。

　　2)设有k只病狗的话，会在第k天被处决，那么，如果有k+1只，病狗的主人只会看到k只病狗，而第k天没有人处决病狗，病狗主人就会在第k+1天知道自己的狗是病狗，于是病狗在第k+1天被处决

　　3)由1)2)得，若有n只病狗，必然在第n天被处决

　　第八题：

　　约定好一个人作为报告人(可以是第一个放风的人)

　　规则如下：

　　1、报告人放风的时候开灯并数开灯次数

　　2、其他人第一次遇到开着灯放风时，将灯关闭

　　3、当报告人第100次开灯的时候，去向监狱长报告，要求监狱长放人......

　　按照概率大约30年后(10000天)他们可以被释放

　　第五组无标准答案  

　　第六组部分题参考答案：  

　　4.

char * strcpy(char * pstrDest,const char * pstrSource)
{
 assert((pstrDest!=NULL)&&(pstrSource!=NULL)); 
 char * pstr=pstrDest;
 while((*(pstrDest++)=*(pstrSource++))!='\0');
        return pstr;
}
 


　　5.

char * strrev(char * pstr)
{
 assert(pstr!=NULL);
 
 char * p=pstr;
 char * pret=pstr;
 while(*(p++)!='\0');
 p--;
 char tmp;
 while(p>pstr)
 {
  tmp=*p;
  *(p--)=*(pstr);
  *(pstr++)=tmp;  
 }
 return pret;

百度笔试题：
IP段格式:ip1 ip2。之间以空格分开，ip形式为X.X.X.X，数据保存在文件中，文件不超过2k行，无序。现在要求编写算法去掉可重IP，可重有三种形式：包含、交叠、紧靠。

例如，文件内容为：
10.0.0.0 10.0.0.12
10.0.0.5 10.0.0.10    ( <= 包含)
10.0.0.8 10.0.0.15    ( <= 交叠)
10.0.0.15 10.0.0.24   ( <= 紧靠)

最后输出为:
10.0.0.0 10.0.0.24