定义：
        将常用的或很复杂的工作，预先用SQL语句写好并用一个指定的名称存储起来,   那么以后要叫数据库提供与已定义好的存储过程的功能相同的服务时,只需调用execute,即可自动完成命令。
        讲到这里,可能有人要问：这么说存储过程就是一堆SQL语句而已啊？
        Microsoft公司为什么还要添加这个技术呢?
        那么存储过程与一般的SQL语句有什么区别呢?

        存储过程的优点：
          1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。
          2.当对数据库进行复杂操作时(如对多个表进行Update,Insert,Query,Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。
          3.存储过程可以重复使用,可减少数据库开发人员的工作量
          4.安全性高,可设定只有某此用户才具有对指定存储过程的使用权
        存储过程的种类：
          1.系统存储过程：以sp_开头,用来进行系统的各项设定.取得信息.相关管理工作,
          如   sp_help就是取得指定对象的相关信息
          2.扩展存储过程   以XP_开头,用来调用操作系统提供的功能
          exec   master..xp_cmdshell   'ping   10.8.16.1'
          3.用户自定义的存储过程,这是我们所指的存储过程
          常用格式
          Create   procedure   procedue_name
          [@parameter   data_type][output]
          [with]{recompile|encryption}
          as
          sql_statement
        解释:  
        output：表示此参数是可传回的
        with   {recompile|encryption}
        recompile:表示每次执行此存储过程时都重新编译一次
        encryption:所创建的存储过程的内容会被加密
        如:
          表book的内容如下
          编号   书名   价格
          001   C语言入门   $30
          002   PowerBuilder报表开发   $52
          实例1:查询表Book的内容的存储过程
          create   proc   query_book
          as  
          select   *   from   book
          go
          exec   query_book
          实例2:加入一笔记录到表book,并查询此表中所有书籍的总金额
          Create   proc   insert_book
          @param1   char(10),@param2   varchar(20),@param3   money,@param4   money   output
          with   encryption   ---------加密
          as
          insert   book(编号,书名，价格）   Values(@param1,@param2,@param3)
          select   @param4=sum(价格)   from   book
          go
          执行例子:  
          declare   @total_price   money  
          exec   insert_book   '003','Delphi   控件开发指南',$100,@total_price
          print   '总金额为'+convert(varchar,@total_price)
          go
        存储过程的3种传回值:
          1.以Return传回整数
          2.以output格式传回参数
          3.Recordset
        传回值的区别:
          output和return都可在批次程式中用变量接收,而recordset则传回到执行批次的客户端中  
        实例3：设有两个表为Product,Order,其表内容如下：
          Product
          产品编号   产品名称   客户订数  
          001   钢笔   30  
          002   毛笔   50  
          003   铅笔   100  
          Order  
          产品编号   客户名   客户订金
          001   南山区   $30
          002   罗湖区   $50
          003   宝安区   $4
        请实现按编号为连接条件,将两个表连接成一个临时表,该表只含编号.产品名.客户名.订金.总金额,
        总金额=订金*订数,临时表放在存储过程中
        代码如下:
          Create   proc   temp_sale
          as
          select   a.产品编号,a.产品名称,b.客户名,b.客户订金,a.客户订数*   b.客户订金   as总金额
          into   #temptable   from   Product   a   inner   join   Order   b   on   a.产品编号=b.产品编号
          if   @@error=0  
          print   'Good'
          else
          print   'Fail'
          go

--------------------------------------------------------------------------------------------------------------------

存储过程介绍  

一、先介绍一下什么是存储过程  
存储过程是利用SQL   Server所提供的Tranact-SQL语言所编写的程序。Tranact-SQL语言是SQL   Server提供专为设计数据库应用程序的语言，它是应用程序和SQL   Server数据库间的主要程序式设计界面。它好比Oracle数据库系统中的Pro-SQL和Informix的数据库系统能够中的Informix-4GL语言一样。这类语言主要提供以下功能，让用户可以设计出符合引用需求的程序：  
1)、变量说明  
2)、ANSI兼容的SQL命令(如Select,Update….)  
3)、一般流程控制命令(if…else…、while….)  
4)、内部函数  

二、存储过程的书写格式  

CREATE   PROCEDURE   [拥有者.]存储过程名[;程序编号]  
[(参数#1,…参数#1024)]  
[WITH  
{RECOMPILE   |   ENCRYPTION   |   RECOMPILE,   ENCRYPTION}  
]  
[FOR   REPLICATION]  
AS   程序行  

其中存储过程名不能超过128个字。每个存储过程中最多设定1024个参数  
(SQL   Server   7.0以上版本),参数的使用方法如下:  

@参数名   数据类型   [VARYING]   [=内定值]   [OUTPUT]  

每个参数名前要有一个“@”符号,每一个存储过程的参数仅为该程序内部使用,参数的类型除了IMAGE外，其他SQL   Server所支持的数据类型都可使用。  
[=内定值]相当于我们在建立数据库时设定一个字段的默认值，这里是为这个参数设定默认值。[OUTPUT]是用来指定该参数是既有输入又有输出值的，也就是在调用了这个存储过程时，如果所指定的参数值是我们需要输入的参数，同时也需要在结果中输出的，则该项必须为OUTPUT，而如果只是做输出参数用，可以用CURSOR，同时在使用该参数时，必须指定VARYING和OUTPUT这两个语句。  

例子:  
CREATE   PROCEDURE   order_tot_amt   @o_id   int,@p_tot   int   output   AS  
SELECT   @p_tot   =   sum(Unitprice*Quantity)  
FROM   orderdetails  
WHERE   ōrdered=@o_id  

例子说明:  
该例子是建立一个简单的存储过程order_tot_amt,这个存储过程根据用户输入的定单ID号码(@o_id),由定单明细表(orderdetails)中计算该定单销售总额[单价(Unitprice)*数量(Quantity)],这一金额通过@p_tot这一参数输出给调用这一存储过程的程序  

三、在SQL   Server中执行存储过程  

在SQL   Server的查询分析器中，输入以下代码:  
declare   @tot_amt   int  
execute   order_tot_amt   1,@tot_amt   output  
select   @tot_amt  

以上代码是执行order_tot_amt这一存储过程，以计算出定单编号为1的定单销售金额，我们定义@tot_amt为输出参数，用来承接我们所要的结果

一、汉字编码的种类

    汉字编码中现在主要用到的有三类，包括GBK，GB2312和Big5。

    1、GB2312又称国标码，由国家标准总局发布，1981年5月1日实施，通行于大陆。新加坡等地也使用此编码。它是一个简化字的编码规范，当然也包括其他的符号、字母、日文假名等，共7445个图形字符，其中汉字占6763个。我们平时说6768个汉字，实际上里边有5个编码为空白，所以总共有6763个汉字。

      GB2312规定“对任意一个图形字符都采用两个字节表示，每个字节均采用七位编码表示”，习惯上称第一个字节为“高字节”，第二个字节为“低字节”。GB2312中汉字的编码范围为，第一字节0xB0-0xF7(对应十进制为176-247)，第二个字节0xA0-0xFE（对应十进制为160-254）。

    GB2312将代码表分为94个区，对应第一字节（0xa1-0xfe）；每个区94个位（0xa1-0xfe），对应第二字节，两个字节的值分别为区号值和位号值加32（2OH），因此也称为区位码。01-09区为符号、数字区，16-87区为汉字区（0xb0-0xf7），10-15区、88-94区是有待进一步标准化的空白区。

       2、Big5又称大五码，主要为香港与台湾使用，即是一个繁体字编码。每个汉字由两个字节构成，第一个字节的范围从0X81－0XFE（即129-255），共126种。第二个字节的范围不连续，分别为0X40－0X7E（即64-126），0XA1－0XFE（即161-254），共157种。

    3、GBK是GB2312的扩展，是向上兼容的，因此GB2312中的汉字的编码与GBK中汉字的相同。另外，GBK中还包含繁体字的编码，它与Big5编码之间的关系我还没有弄明白，好像是不一致的。GBK中每个汉字仍然包含两个字节，第一个字节的范围是0x81-0xFE（即129-254），第二个字节的范围是0x40-0xFE（即64-254）。GBK中有码位23940个，包含汉字21003个。

                                   表1 汉字编码范围

二、对汉字进行hash

    为了处理汉字的方便，在查找汉字的时候，我们通常会用到hash的方法，那怎么来确定一个汉字位置呢？这就和每种编码的排列有关了，这里主要给出一种hash函数的策略。

    对于GB2312编码，设输入的汉字为GBword，我们可以采用公式(C1-176)*94 + (C2-161)确定GBindex。其中，C1表示第一字节，C2表示第二字节。具体如下：

    GBindex = ((unsigned char)GBword.at(0)-176)*94 + (unsigned char)GBword.at(1) - 161;

    之所以用unsigned char类型，是因为char是一个字节，如果用unsigend int，因为int是4个字节的，所以会造成扩展，导致错误。

       对于GBK编码，设输入的汉字为GBKword，则可以采用公式   index=(ch1-0x81)*190+(ch2-0x40)-(ch2/128)，其中ch1是第一字节，ch2是第二字节。

    具体的，

    GBKindex = ((unsigned char)GBKword[0]-129)*190 +

               ((unsigned char)GBKword[1]-64) - (unsigned char)GBKword[1]/128;

三、怎样判断一个汉字的是什么编码

直接根据汉字的编码范围判断，对于GB2312和GBK可用下面两个程序实现。

1、判断是否是GB2312

bool isGBCode(const string& strIn)

{

    unsigned char ch1;

    unsigned char ch2;

    if (strIn.size() >= 2)

    {

        ch1 = (unsigned char)strIn.at(0);

        ch2 = (unsigned char)strIn.at(1);

        if (ch1>=176 && ch1<=247 && ch2>=160 && ch2<=254)

            return true;

        else return false;

    }

    else return false;

}

2、判断是否是GBK编码

bool isGBKCode(const string& strIn)

{

    unsigned char ch1;

    unsigned char ch2;

    if (strIn.size() >= 2)

    {

        ch1 = (unsigned char)strIn.at(0);

        ch2 = (unsigned char)strIn.at(1);

        if (ch1>=129 && ch1<=254 && ch2>=64 && ch2<=254)

            return true;

        else return false;

    }

    else return false;

}

3、对于Big5

    它的范围为：高字节从0xA0到0xFE，低字节从0x40到0x7E，和0xA1到0xFE两部分。判断一个汉字是否是BIG5编码，可以如上对字符的编码范围判断即可。如何定位呢？那么也想象所有编码排列为一个二维坐标，纵坐标是高字节，横坐标是低字节。这样一行上的汉字个数：(0x7E-0x40+1)+(0xFE-0xA1+1)＝157。那么定位算法分两块，为:  

    if 0x40<=ch2<=0x7E: #is big5 char

    index=((ch1-0xA1)*157+(ch2-0x40))*2

    elif 0xA1<=ch2<=0xFE: #is big5 char

    index=((ch1-0xA1)*157+(ch2-0xA1+63))*2

对于第二块，计算偏移量时因为有两块数值，所以在计算后面一段值时，不要忘了前面还有一段值。0x7E-0x40+1=63。

四、如果判断一个字符是西文字符还是中文字符

    大家知道西文字符主要是指ASCII码，它用一个字节表示。且这个字符转换成数字之后，该数字是大于0的，而汉字是两个字节的，第一个字节的转化为数字之后应该是小于0的，因此可以根据每个字节转化为数字之后是否小于0，判断它是否是汉字。

    例如，设输入字为strin，则，

     If (strin.at(0) < 0)

       cout << ”是汉字” << endl;

     else cout << ”不是汉字” << endl;

常用数据类型使用转换详解
作者：程佩君

The GetDC function retrieves a handle of a display device context (DC) for the client area of the specified window. The display device context can be used in subsequent GDI functions to draw in the client area of the window.

This function retrieves a common, class, or private device context depending on the class style specified for the specified window. For common device contexts, GetDC assigns default attributes to the device context each time it is retrieved. For class and private device contexts, GetDC leaves the previously assigned attributes unchanged.

HDC GetDC(

    HWND hWnd                 // handle of window 

   );         

Parameters

hWnd

Identifies the window whose device context is to be retrieved.

GetWindowDC

The GetWindowDC function retrieves the device context (DC) for the entire window, including title bar, menus, and scroll bars. A window device context permits painting anywhere in a window, because the origin of the device context is the upper-left corner of the window instead of the client area.

GetWindowDC assigns default attributes to the window device context each time it retrieves the device context. Previous attributes are lost.

HDC GetWindowDC(

    HWND hWnd                 // handle of window 

   );         

Parameters

hWnd

Identifies the window with a device context that is to be retrieved.

以往，我们所使用的语言，比如C，C++等等，都称为静态语言。什么是静态语言呢？就是说，在使用数据之前，我们必须首先定义数据类型，这些数据类型包括int, float, double等等。就相当于在使用它们之前，首先要为它们分配好内存空间；而动态语言就刚刚是相反的，它是在得到数据类型之后，再为它分配内存空间。

“脚本语言除了接近口语化的设计外，另加上简化后的语法。（除了内建的命令外，通常仅需简单的逻辑判断与数值计算即可胜任）因此用脚本语言制作游戏，不再是非程序员不可的工作（除了系统本身的修订），企画人员也可以很快地进入状态。另外，如果将来需要将游戏移植到其他平台时，比起程序与资料的盘根错节的设计，利用脚本语言来开发的游戏，只需要修改系统本身，脚本语言部分本身毋须更动，相形之下出现问题的机会与范围就缩小了很多。

偶又试了一次，发现lines number可能是有问题的，而且也不是我的那种算法。不过函数名肯定是对的

在vckbase中又发现一篇好文，所以就又贴过来了。不过可惜的是，还是没能解决dll的地址映射问题，无法track到dll内的信息，可惜了。

对“仅通过崩溃地址找出源代码的出错行”一文的补充与改进

作者：上海伟功通信 roc

下载源代码

　　读了老罗的“仅通过崩溃地址找出源代码的出错行”(下称"罗文")一文后，感觉该文还是可以学到不少东西的。不过文中尚存在有些说法不妥，以及有些操作太繁琐的地方 。为此，本人在学习了此文后，在多次实验实践基础上，把该文中的一些内容进行补充与改进，希望对大家调试程序，尤其是release版本的程序有帮助 。欢迎各位朋友批评指正。


一、该方法适用的范围
　　在windows程序中造成程序崩溃的原因很多，而文中所述的方法仅适用与:由一条语句当即引起的程序崩溃。如原文中举的除数为零的崩溃例子。而笔者在实际工作中碰到更多的情况是:指针指向一非法地址 ，然后对指针的内容进行了，读或写的操作。例如：

void Crash1()
{
char * p =(char*)100;
*p=100;
}

　　这些原因造成的崩溃，无论是debug版本，还是release版本的程序，使用该方法都可找到造成崩溃的函数或子程序中的语句行，具体方法的下面还会补充说明。 另外，实践中另一种常见的造成程序崩溃的原因:函数或子程序中局部变量数组越界付值，造成函数或子程序返回地址遭覆盖，从而造成函数或子程序返回时崩溃。例如:

#include 
void Crash2();
int main(int argc,char* argv[])
{
Crash2();
return 0;
}
void Crash2()
{
char p[1];
strcpy(p,"0123456789");
}

在vc中编译运行此程序的release版本，会跳出如下的出错提示框。


图一 上面例子运行结果

　　这里显示的崩溃地址为:0x34333231。这种由前面语句造成的崩溃根源，在后续程序中方才显现出来的情况，显然用该文所述的方法就无能为力了。不过在此例中多少还有些蛛丝马迹可寻找到崩溃的原因:函数Crash2中的局部数组p只有一个字节大小 ，显然拷贝"0123456789"这个字符串会把超出长度的字符串拷贝到数组p的后面，即*(p+1)=''1''，*(p+2)=''2''，*(p+3)=''3''，*(p+4)=4。。。。。。而字符''1''的ASC码的值为0x31，''2''为0x32，''3''为0x33，''4''为0x34。。。。。，由于intel的cpu中int型数据是低字节保存在低地址中 ，所以保存字符串''1234''的内存，显示为一个4字节的int型数时就是0x34333231。显然拷贝"0123456789"这个字符串时，"1234"这几个字符把函数Crash2的返回地址给覆盖 ，从而造成程序崩溃。对于类似的这种造成程序崩溃的错误朋友们还有其他方法排错的话，欢迎一起交流讨论。


二、设置编译产生map文件的方法
　　该文中产生map文件的方法是手工添加编译参数来产生map文件。其实在vc6的IDE中有产生map文件的配置选项的。操作如下:先点击菜单"Project"->"Settings。。。"，弹出的属性页中选中"Link"页 ，确保在"category"中选中"General"，最后选中"Generate mapfile"的可选项。若要在在map文件中显示Line numbers的信息的话 ，还需在project options 中加入/mapinfo:lines 。Line numbers信息对于"罗文"所用的方法来定位出错源代码行很重要 ，但笔者后面会介绍更加好的方法来定位出错代码行，那种方法不需要Line numbers信息。


图二 设置产生MAP文件


三、定位崩溃语句位置的方法
　　"罗文"所述的定位方法中，找到产生崩溃的函数位置的方法是正确的，即在map文件列出的每个函数的起始地址中，最近的且不大于崩溃地址的地址即为包含崩溃语句的函数的地址 。但之后的再进一步的定位出错语句行的方法不是最妥当，因为那种方法前提是，假设基地址的值是 0x00400000 ，以及一般的 PE 文件的代码段都是从 0x1000偏移开始的 。虽然这种情况很普遍，但在vc中还是可以基地址设置为其他数，比如设置为0x00500000，这时仍旧套用

 崩溃行偏移 = 崩溃地址 - 0x00400000 - 0x1000 

的公式显然无法找到崩溃行偏移。 其实上述公式若改为

崩溃行偏移 = 崩溃地址 - 崩溃函数绝对地址 + 函数相对偏移

即可通用了。仍以"罗文"中的例子为例:"罗文"中提到的在其崩溃程序的对应map文件中，崩溃函数的编译结果为

0001:00000020 ?Crash@@YAXXZ 00401020 f CrashDemo。obj 

对与上述结果，在使用我的公式时 ，"崩溃函数绝对地址"指00401020， 函数相对偏移指 00000020， 当崩溃地址= 0x0040104a时， 则 崩溃行偏移 = 崩溃地址 - 崩溃函数起始地址+ 函数相对偏移 = 0x0040104a - 0x00401020 + 0x00000020= 0x4a，结果与"罗文"计算结果相同 。但这个公式更通用。


四、更好的定位崩溃语句位置的方法。
　　其实除了依靠map文件中的Line numbers信息最终定位出错语句行外，在vc6中我们还可以通过编译程序产生的对应的汇编语句，二进制码，以及对应c/c++语句为一体的"cod"文件来定位出错语句行 。先介绍一下产生这种包含了三种信息的"cod"文件的设置方法:先点击菜单"Project"->"Settings。。。"，弹出的属性页中选中"C/C++"页 ，然后在"Category"中选则"Listing Files"，再在"Listing file type"的组合框中选择"Assembly，Machine code， and source"。接下去再通过一个具体的例子来说明这种方法的具体操作。


图三 设置产生"cod"文件

准备步骤1)产生崩溃的程序如下:

01 //****************************************************************
02 //文件名称：crash。cpp
03 //作用:    演示通过崩溃地址找出源代码的出错行新方法
04 //作者：   伟功通信 roc
05 //日期：   2005-5-16
06//****************************************************************
07 void Crash1();
08 int main(int argc,char* argv[])
09 {
10 Crash1();
11 return 0;
12 }
13
14 void Crash1()
15 {
16  char * p =(char*)100;
17  *p=100;
18 }

准备步骤2)按本文所述设置产生map文件(不需要产生Line numbers信息)。
准备步骤3)按本文所述设置产生cod文件。
准备步骤4)编译。这里以debug版本为例(若是release版本需要将编译选项改为不进行任何优化的选项，否则上述代码会因为优化时看作废代码而不被编译，从而看不到崩溃的结果)，编译后产生一个"exe"文件 ，一个"map"文件，一个"cod"文件。
运行此程序，产生如下如下崩溃提示:


图四 上面例子运行结果

排错步骤1)定位崩溃函数。可以查询map文件获得。我的机器编译产生的map文件的部分如下:

 Crash
Timestamp is 42881a01 (Mon May 16 11:56:49 2005)
Preferred load address is 00400000
Start Length Name Class
0001:00000000 0000ddf1H .text CODE
0001:0000ddf1 0001000fH .textbss CODE
0002:00000000 00001346H .rdata DATA
0002:00001346 00000000H .edata DATA
0003:00000000 00000104H .CRT$XCA DATA
0003:00000104 00000104H .CRT$XCZ DATA
0003:00000208 00000104H .CRT$XIA DATA
0003:0000030c 00000109H .CRT$XIC DATA
0003:00000418 00000104H .CRT$XIZ DATA
0003:0000051c 00000104H .CRT$XPA DATA
0003:00000620 00000104H .CRT$XPX DATA
0003:00000724 00000104H .CRT$XPZ DATA
0003:00000828 00000104H .CRT$XTA DATA
0003:0000092c 00000104H .CRT$XTZ DATA
0003:00000a30 00000b93H .data DATA
0003:000015c4 00001974H .bss DATA
0004:00000000 00000014H .idata$2 DATA
0004:00000014 00000014H .idata$3 DATA
0004:00000028 00000110H .idata$4 DATA
0004:00000138 00000110H .idata$5 DATA
0004:00000248 000004afH .idata$6 DATA
Address Publics by Value Rva+Base Lib:Object
0001:00000020 _main 00401020 f Crash.obj
0001:00000060 ?Crash1@@YAXXZ 00401060 f Crash.obj
0001:000000a0 __chkesp 004010a0 f LIBCD:chkesp.obj
0001:000000e0 _mainCRTStartup 004010e0 f LIBCD:crt0.obj
0001:00000210 __amsg_exit 00401210 f LIBCD:crt0.obj
0001:00000270 __CrtDbgBreak 00401270 f LIBCD:dbgrpt.obj
...

对于崩溃地址0x00401082而言，小于此地址中最接近的地址(Rva+Base中的地址)为00401060，其对应的函数名为?Crash1@@YAXXZ，由于所有以问号开头的函数名称都是 C++ 修饰的名称 ，"@@YAXXZ"则为区别重载函数而加的后缀，所以?Crash1@@YAXXZ就是我们的源程序中，Crash1() 这个函数。
排错步骤2)定位出错行。打开编译生成的"cod"文件，我机器上生成的文件内容如下:

 TITLE E:\Crash\Crash。cpp
.386P
include listing.inc
if @Version gt 510
.model FLAT
else
_TEXT SEGMENT PARA USE32 PUBLIC ''CODE''
_TEXT ENDS
_DATA SEGMENT DWORD USE32 PUBLIC ''DATA''
_DATA ENDS
CONST SEGMENT DWORD USE32 PUBLIC ''CONST''
CONST ENDS
_BSS SEGMENT DWORD USE32 PUBLIC ''BSS''
_BSS ENDS
$$SYMBOLS SEGMENT BYTE USE32 ''DEBSYM''
$$SYMBOLS ENDS
$$TYPES SEGMENT BYTE USE32 ''DEBTYP''
$$TYPES ENDS
_TLS SEGMENT DWORD USE32 PUBLIC ''TLS''
_TLS ENDS
; COMDAT _main
_TEXT SEGMENT PARA USE32 PUBLIC ''CODE''
_TEXT ENDS
; COMDAT ?Crash1@@YAXXZ
_TEXT SEGMENT PARA USE32 PUBLIC ''CODE''
_TEXT ENDS
FLAT GROUP _DATA， CONST, _BSS
ASSUME CS: FLAT, DS: FLAT, SS: FLAT
endif
PUBLIC ?Crash1@@YAXXZ     ; Crash1
PUBLIC _main
EXTRN __chkesp:NEAR
; COMDAT _main
_TEXT SEGMENT
_main PROC NEAR     ; COMDAT
; 9    : {
00000 55   push  ebp
00001 8b ec   mov  ebp， esp
00003 83 ec 40  sub  esp, 64   ; 00000040H
00006 53   push  ebx
00007 56   push  esi
00008 57   push  edi
00009 8d 7d c0  lea  edi, DWORD PTR [ebp-64]
0000c b9 10 00 00 00  mov  ecx， 16   ; 00000010H
00011 b8 cc cc cc cc  mov  eax， -858993460  ; ccccccccH
00016 f3 ab   rep stosd
; 10   :  Crash1();
00018 e8 00 00 00 00  call  ?Crash1@@YAXXZ  ; Crash1
; 11   :  return 0;
0001d 33 c0   xor  eax， eax
; 12   : }
0001f 5f   pop  edi
00020 5e   pop  esi
00021 5b   pop  ebx
00022 83 c4 40  add  esp, 64   ; 00000040H
00025 3b ec   cmp  ebp, esp
00027 e8 00 00 00 00  call  __chkesp
0002c 8b e5   mov  esp, ebp
0002e 5d   pop  ebp
0002f c3   ret  0
_main ENDP
_TEXT ENDS
; COMDAT ?Crash1@@YAXXZ
_TEXT SEGMENT
_p$ = -4
?Crash1@@YAXXZ PROC NEAR    ; Crash1, COMDAT
; 15   : {
00000 55   push  ebp
00001 8b ec   mov  ebp, esp
00003 83 ec 44  sub  esp, 68   ; 00000044H
00006 53   push  ebx
00007 56   push  esi
00008 57   push  edi
00009 8d 7d bc  lea  edi, DWORD PTR [ebp-68]
0000c b9 11 00 00 00  mov  ecx, 17   ; 00000011H
00011 b8 cc cc cc cc  mov  eax, -858993460  ; ccccccccH
00016 f3 ab   rep stosd
; 16   :  char * p =(char*)100;
00018 c7 45 fc 64 00
00 00   mov  DWORD PTR _p$[ebp], 100 ; 00000064H
; 17   :  *p=100;
0001f 8b 45 fc  mov  eax, DWORD PTR _p$[ebp]
00022 c6 00 64  mov  BYTE PTR [eax], 100 ; 00000064H
; 18   : }
00025 5f   pop  edi
00026 5e   pop  esi
00027 5b   pop  ebx
00028 8b e5   mov  esp, ebp
0002a 5d   pop  ebp
0002b c3   ret  0
?Crash1@@YAXXZ ENDP     ; Crash1
_TEXT ENDS
END

其中

?Crash1@@YAXXZ PROC NEAR    ; Crash1, COMDAT

为Crash1汇编代码的起始行。产生崩溃的代码便在其后的某个位置。接下去的一行为:

; 15   : {

冒号后的"{"表示源文件中的语句，冒号前的"15"表示该语句在源文件中的行数。 这之后显示该语句汇编后的偏移地址，二进制码，汇编代码。如

00000 55   push  ebp

其中"0000"表示相对于函数开始地址后的偏移，"55"为编译后的机器代码，" push ebp"为汇编代码。从"cod"文件中我们可以看出，一条(c/c++)语句通常需要编译成数条汇编语句 。此外有些汇编语句太长则会分两行显示如:

00018 c7 45 fc 64 00
00 00   mov  DWORD PTR _p$[ebp], 100 ; 00000064H

其中"0018"表示相对偏移，在debug版本中，这个数据为相对于函数起始地址的偏移(此时每个函数第一条语句相对偏移为0000)；release版本中为相对于代码段第一条语句的偏移(即代码段第一条语句相对偏移为0000，而以后的每个函数第一条语句相对偏移就不为0000了)。"c7 45 fc 64 00 00 00 "为编译后的机器代码 ，"mov DWORD PTR _p$[ebp]， 100"为汇编代码， 汇编语言中";"后的内容为注释，所以";00000064H"，是个注释这里用来说明100转换成16进制时为"00000064H"。
接下去，我们开始来定位产生崩溃的语句。
第一步，计算崩溃地址相对于崩溃函数的偏移，在本例中已经知道了崩溃语句的地址(0x00401082)，和对应函数的起始地址(0x00401060)，所以崩溃地址相对函数起始地址的偏移就很容易计算了:

  崩溃偏移地址 = 崩溃语句地址 - 崩溃函数的起始地址 = 0x00401082 - 0x00401060 = 0x22。

第二步，计算出错的汇编语句在cod文件中的相对偏移。我们可以看到函数Crash1()在cod文件中的相对偏移地址为0000，则

崩溃语句在cod文件中的相对偏移 =  崩溃函数在cod文件中相对偏移 + 崩溃偏移地址 = 0x0000 + 0x22 = 0x22

第三步，我们看Crash1函数偏移0x22除的代码是什么?结果如下

 00022 c6 00 64  mov  BYTE PTR [eax], 100 ; 00000064H

这句汇编语句表示将100这个数保存到寄存器eax所指的内存单元中去，保存空间大小为1个字节(byte)。程序正是执行这条命令时产生了崩溃，显然这里eax中的为一个非法地址 ，所以程序崩溃了!
第四步，再查看该汇编语句在其前面几行的其对应的源代码，结果如下:

; 17   :  *p=100;

其中17表示该语句位于源文件中第17行，而“*p=100;”这正是源文件中产生崩溃的语句。
至此我们仅从崩溃地址就查找出了造成崩溃的源代码语句和该语句所在源文件中的确切位置，甚至查找到了造成崩溃的编译后的确切汇编代码!
怎么样，是不是感觉更爽啊?


五、小节

1、新方法同样要注意可以适用的范围，即程序由一条语句当即引起的崩溃。另外我不知道除了VC6外，是否还有其他的编译器能够产生类似的"cod"文件。
2、我们可以通过比较 新方法产生的debug和releae版本的"cod"文件，查找那些仅release版本(或debug版本)有另一个版本没有的bug(或其他性状)。例如"罗文"中所举的那个用例 ，只要打开release版本的"cod"文件，就明白了为啥debug版本会产生崩溃而release版本却没有:原来release版本中产生崩溃的语句其实根本都没有编译 。同样本例中的release版本要看到崩溃的效果，需要将编译选项改为为不优化的配置。

DeinoMPI是微软windows下MPI-2的一个实现。

注：MPI-2是Message Passing Interface, http://www.mpi-forum.org/。What is MPI? MPI is a library of functions and macros which is intended for use in programs that exploit the existence of multiple processors by message-passing. 也就是说，MPI是一套规范，定义了一些函数和宏，它被用来在程序中通过消息传递来发挥多处理器的处理能力。

DeinoMPI is an implementation of the MPI-2 standard for parallel computing or more generally it is system level middle-ware for high performance parallel computing on Microsoft Windows systems. It supports Win32 and Win64 machines.

DeinoMPI是MPI-2的一个实现，MPI-2是for并行计算的。更通用地说，DeinoMPI是windows系统上的一个高性能并行计算的系统level中间件。它有两个版本，分别是for win32和for win64的。

1) DeinoMPI provides the libraries necessary for software developers to write parallel applications that conform to the MPI-2 standard for parallel computing.  Software developers who wish to develop new parallel applications or wish to add parallel capabilities to existing software would benefit from using DeinoMPI.  The libraries provided support a wide range of C, C++ and Fortran compilers.

2) DeinoMPI also provides a process manager used to start processes on multiple machines in a cluster remotely.  Microsoft Windows does not provide native capability to start user applications on remote machines.  DeinoMPI provides a secure mechanism to do just that.  The primary purpose of the DeinoMPI process manager is to set up the environment and launch processes used in MPI jobs but it is not restricted to this functionality.  It can launch any application remotely on behalf of the user.

The following users will benefit from DeinoMPI: Businesses that develop software and wish to add parallel capabilities to increase the performance of their software.  Research institutions that have parallel software codes that they want to run on their Windows machines.  Universities or other educational institutions that teach courses on parallel computing.  University or research labs that run computationally intensive software and wish to use parallel versions of their software to better utilize their computer resources.  Students or hobbyists that wish to write parallel programs.

以下再用图来表示:

在VC等绝大多数C编译器中，默认情况下，参数进栈的顺序是由右向左的，因此，参数进栈以后的内存模型如下图所示：最后一个固定参数的地址位于第一个可变参数之下，并且是连续存储的。
|——————————————————————————|
|最后一个可变参数 | ->高内存地址处
|——————————————————————————|
...................
|——————————————————————————|
|第N个可变参数 | ->va_arg(arg_ptr,int)后arg_ptr所指的地方,
| | 即第N个可变参数的地址。
|——————————————— |
………………………….
|——————————————————————————|
|第一个可变参数 | ->va_start(arg_ptr,start)后arg_ptr所指的地方
| | 即第一个可变参数的地址
|——————————————— |
|———————————————————————— ——|
| |
|最后一个固定参数 | -> start的起始地址
|—————————————— —| .................
|—————————————————————————— |
| |
|——————————————— |-> 低内存地址处

三.printf研究

下面是一个简单的printf函数的实现，参考了中的156页的例子，读者可以结合书上的代码与本文参照。
#include "stdio.h"
#include "stdlib.h"
void myprintf(char* fmt, ...) //一个简单的类似于printf的实现，//参数必须都是int 类型
{
char* pArg=NULL; //等价于原来的va_list
char c;

pArg = (char*) &fmt; //注意不要写成p = fmt !!因为这里要对//参数取址，而不是取值
pArg += sizeof(fmt); //等价于原来的va_start

do
{
c =*fmt;
if (c != '%')
{
putchar(c); //照原样输出字符
}
else
{
//按格式字符输出数据
switch(*++fmt)
{
case 'd':
printf("%d",*((int*)pArg));
break;
case 'x':
printf("%#x",*((int*)pArg));
break;
default:
break;
}
pArg += sizeof(int); //等价于原来的va_arg
}
++fmt;
}while (*fmt != '\0');
pArg = NULL; //等价于va_end
return;
}
int main(int argc, char* argv[])
{
int i = 1234;
int j = 5678;

myprintf("the first test:i=%d",i,j);
myprintf("the secend test:i=%d; %x;j=%d;",i,0xabcd,j);
system("pause");
return 0;
}
在intel+win2k+vc6的机器执行结果如下：
the first test:i=1234
the secend test:i=1234; 0xabcd;j=5678;

四.应用
求最大值:
#include //不定数目参数需要的宏
int max(int n,int num,...)
{
va_list x;//说明变量x
va_start(x,num);//x被初始化为指向num后的第一个参数
int m=num;
for(int i=1;i {
//将变量x所指向的int类型的值赋给y,同时使x指向下一个参数
int y=va_arg(x,int);
if(y>m)m=y;
}
va_end(x);//清除变量x
return m;
}
main()
{
printf("%d,%d",max(3,5,56),max(6,0,4,32,45,533));
}

本文转载自网上，本来是要注明出处的，结果别人也都是转载的，呵呵。不过此文讲的很不错，很清楚，特别是把可变参数实现的那几个宏！偶也是冲着这几个宏去的。

#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
这个宏，一开始我就是想不明白！不知道是老了，还是笨了，或者是生锈了。想了好一会还是没搞明白，不过看了一下本文的分析，一下子就明白了，那是相当的恍然大悟啊。

#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

这个宏，一开始也是没有明白。多看了好几遍才发现了奥秘所在啊，为什么要加一个，然后再减一个呢？因为第一个加直接加到ap上去了，而后一个减只是减了一下括号内的值，也就是当前值了。

宏真是厉害啊！或者说它应用真广！这不禁让我想起以前看过的宏，怎么判断是win还是linux平台的，怎么判断是32位的还是64位的。宏是一门学问啊。

本文的另一大优点是，有非常简单的例子，看了就懂。恩。看了保管你就会用了。不过这年头指针也是个好东西啊，需要什么，传个指针就是传了一切想要的东西啊，只要让指针指向你需要的东西，可以是任意多的参数（不过这样子的话，具体到哪个参数结束就要我们自己来定了，不像这里，所有的参数都已经压栈了，编译器可以帮我们决定具体有多少个参数，到什么时候结束）。

Have fun.

不过我想上面说的应该是国外吧！不知道国内的90年代OO是否风靡啊。偶是21世纪才开始接触电脑的。记得那时候老师在给我们上C++课的时候，拼命说什么C++好啊，面向对象啊，大说了一通。总之，给我的感觉是，OO才开始风靡。后来，学校里又开了一门课，叫着面向对象×××什么什么的，忘了，反正就是在讲面向对象。老师也是一个劲的给我们灌输OO思想，叫我们区别好OO与OP的差别。不知道为什么会有这么一段，可能想说国内的技术比国外的慢太多了。很多时候，其实，语言也是一种原因！毕竟国内好的翻译太少了！而且不能总是等侯杰大叔叔来翻译啊。记得以前在论坛上看到一句“名言”啊：不要看国内作者写的书，不要看国内译者翻译的书，括弧（侯杰除外）。看起来似乎有点偏激，不过却不无道理啊！很多的作者和译者都是垃圾啊！！！！偶深受其害，因为偶很爱买书（看书就。。。呵呵）。记得我去年看重构的时候，我觉得这个名词还是很新的啊，看了那本书之后才发现原来这本书写于上个世纪，昏迷啊，国内的技术太落后了。偶的e文也太落后了！要多关注关注国外的新技术。

扯远了。回来再谈OO。

OO，很早就已经学过了，很早以前就以为自己懂了，今天突然发现自己还不懂什么是OO，为什么要OO？以前的想法可能太简单了一点，认为只要是全都是对象就是OO了。

没错，在OO的思想中，所有一切东西都是O！但是，我发现在实际编程中，我连这一点都无法保证！而且，我也无法做到理论联系实际，把理论应用到实际。在实际运用中，几乎没有考虑过O的问题。更多的时候是在考虑什么模块怎么划分，一个模块应该有几个类阿，每个类都有些什么功能阿。但是我没有把那个类作为一个对象来考虑，或者说没有把那个类作为一类抽象的对象来考虑。需要什么东西就直接往里面加。不管加的东西跟那个类有没有关系，都往里面塞！行为相当恶劣。简直就是OP啊，每个类都成了一组function的wrapper了，相当悲哀！不管function是否应该属于该类（或者说该对象）。搞不好什么时候就设计出个：一个人有爬的行为！（结果肯定会被一群人狂揍哦）。

OO有什么优点呢？为什么要OO？

OO使人们得变成与实际的世界更加接近，所有的对象被赋予属性和方法，结果编程就更加富有人性化。

维护简单，模块化是面向对象编程中的一个特征。实体被表示为类和同一名字空间中具有相同功能的类，我们可以在名字空间中添加一个类而不会影响该名字空间的其他成员。

可扩充性，面向对象编程从本质上支持扩充性。如果有一个具有某种功能的类，就可以很快地扩充这个类，创建一个具有扩充的功能的类。

代码重用，由于功能是被封装在类中的，并且类是作为一个独立实体而存在的，提供一个类库就非常简单了。事实上，任何一个.NET Framework编程语言的程序员都可以使用.NET Framework类库，.NET Framework类库提供了很多的功能。更令人高兴的是，我们可以通过提供符合需求的类来扩充这些功能。

在实际的编程中你有考虑过这些问题吗？Sorry，偶是没有考虑过。基本上是，维护很难！扩充相对较容易，因为直接拷贝过来，在修改（这有算是OO吗？显然否）。这种根本就是没有利用到面向对象中的重用性。扩充起来也不容易，需要什么功能就胡乱继承一通，搞得类的层次太多了，无形之中给后人维护带来了极大的困难。出现这些情况的原因是什么呢？前面的代码设计的不够好。面向对象的三大特点：封装，继承和多态有没有都考虑进来？面向对象是一种思想，是我们考虑事情的方法，通常表现为我们是将问题的解决按照过程方式来解决呢，还是将问题抽象为一个对象来解决它。很多情况下，我们会不知不觉的按照过程方式来解决它，而不是考虑将要解决问题抽象为对象去解决它。有些人打着面向对象的幌子，干着过程编程的勾当。

OOA呢？OO对A有什么帮助呢？

OOA的主要优点

·         加强了对问题域和系统责任的理解；

·         改进与分析有关的各类人员之间的交流；

·         对需求的变化具有较强的适应性；

·         支持软件复用。

·         贯穿软件生命周期全过程的一致性。

·         实用性；

·         有利于用户参与。

OOA方法的基本步骤
 
在用OOA具体地分析一个事物时，大致上遵循如下五个基本步骤：
第一步，确定对象和类。这里所说的对象是对数据及其处理方式的抽象，它反映了系统保存和处理现实世界中某些事物的信息的能力。类是多个对象的共同属性和方法集合的描述，它包括如何在一个类中建立一个新对象的描述。

第二步，确定结构（structure）。结构是指问题域的复杂性和连接关系。类成员结构反映了泛化-特化关系，整体-部分结构反映整体和局部之间的关系。

第三步，确定主题（subject）。主题是指事物的总体概貌和总体分析模型。

第四步，确定属性（attribute）。属性就是数据元素，可用来描述对象或分类结构的实例，可在图中给出，并在对象的存储中指定。

第五步，确定方法（method）。方法是在收到消息后必须进行的一些处理方法：方法要在图中定义，并在对象的存储中指定。对于每个对象和结构来说，那些用来增加、修改、删除和选择一个方法本身都是隐含的（虽然它们是要在对象的存储中定义的，但并不在图上给出），而有些则是显示的。

OO是个好东西啊。要理解OO的思想，并能够在实际中运用它。不过OO现在已经不是最热的了，在现在web2.0的年代，基于网页上的应用会更火啊。你开发个软件，如果是单机版的，你都不好意思说！如果是C/S架构的，你也是会被BS的。呵呵。现在什么SOA，AJAX那个火 啊！SOA是service oriented architecture，AJAX是什么东东？中间件、CRP、CPM等等，现在也是牛一B啊。学无止尽，学不能晒网啊；跟上时代的脚步，对新技术保持必要的触觉。恩。

以上纯属胡言乱语，部分摘自网上。如果有兴趣，偶欢迎大家一起来讨论啊。

几点小说明
1、该文是针对vc6.0的，不过vs2003同样适用
 In the C/C++ tab, select "Line Numbers Only" for Debug Info
 对应于 Release-->C/C++ tab-->调试信息格式-->仅限行号(/Zd)
 
 type the switches /MAPINFO:LINES and /MAPINFO:EXPORTS in the Project Options edit box.
 对应于 Release-->链接器-->命令行-->附加选项(D): /MAPINFO:LINES /MAPINFO:EXPORTS

2、 该文举的例子在查找行号的时候正好有一个与之对应的
 119 0001:000001a1
 不过我在试的时候，没有一个地址正好一致的。比如说我要找的是00000049，但是上面的信息只有
 25 0001:00000042
 27 0001:0000004a
 是第25行呢？还是第27行？结果都不对，正确的似乎是49-42+25=32(32正好是源代码中出错的那一行，不知是不是巧合，未严格验证过！)
 
3、Line numbers信息有很多
 Line numbers for .\release\main.obj(d:\main.cpp) segment .text
 Line numbers for C:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\lib\LIBC.lib(F:\VS70Builds\3077\vc\crtbld\crt\src\intel\strncpy.asm) segment .text
 ...
 不过地址都是不一样的了（这个我也未严格验证）
 
4、既然都是可以算出来的，那是不是可以写一个软件来自动算出crash在哪一行呢？有现成的吗？有空研究一下。恩。

Have fun.

Introduction

Programming neat applications is one thing. But when a user informs you your software has crashed, you know it's best to fix this before adding other features. If you're lucky enough, the user will have a crash address. This will go a long way in solving the problem. But how can you determine what went wrong, using this crash address?

Creating a MAP file

Well first of all, you'll need a MAP file. If you don't have one, it will be nearly impossible to find where your application crashed using the crash address. So first, I'll show you how to create a good MAP file. For this, I will create a new project (MAPFILE). You can do the same, or adjust your own project. I create a new project using the Win32 Application option in VC++ 6.0, selecting the 'typical "Hello Word!" application' to keep the size of the MAP file reasonable for explanation.

Once created we need to adjust the project settings for the release version. In the C/C++ tab, select "Line Numbers Only" for Debug Info.

Many people forget this, but you'll need this option if you want a good MAP file. This will not affect your release in any way. Next is the Link tab. Here you need to select the "Generate mapfile" option. Also, type the switches /MAPINFO:LINES and /MAPINFO:EXPORTS in the Project Options edit box.

Now, you're ready to compile and link your project. After linking, you will find a .map file in your intermediate directory (together with your exe).

Reading the MAP file

After all this dull work, now comes the neat part: how to read the MAP file. We'll do this by using a crash example. So first: how to crash your application. I did this by adding these two lines at the end of the InitInstance() function:

char* pEmpty = NULL;
*pEmpty = 'x'; // This is line 119

I'm sure you can find other instructions which will crash your application. Now recompile and link. If you start the application, it will crash and you'll get a message like this: 'The instruction at "0x004011a1" referenced memory at "0x00000000". The memory could not be "Written".' .

Now, it's time to open the MAP file with notepad or something similar. You MAP file will look like this:

The top of the MAP file contains the module name, the timestamp indicating the link of the project, and the preferred load address (which will probably be 0x00400000 unless you're using a dll). After the header comes the section information that shows which sections the linker brought in from the various OBJ and LIB files.

Collapse

MAPFILE
Timestamp is 3df6394d (Tue Dec 10 19:58:21 2002)
Preferred load address is 00400000
Start         Length     Name                   Class
0001:00000000 000038feH .text                   CODE
0002:00000000 000000f4H .idata$5                DATA
0002:000000f8 00000394H .rdata                  DATA
0002:0000048c 00000028H .idata$2                DATA
0002:000004b4 00000014H .idata$3                DATA
0002:000004c8 000000f4H .idata$4                DATA
0002:000005bc 0000040aH .idata$6                DATA
0002:000009c6 00000000H .edata                  DATA
0003:00000000 00000004H .CRT$XCA                DATA
0003:00000004 00000004H .CRT$XCZ                DATA
0003:00000008 00000004H .CRT$XIA                DATA
0003:0000000c 00000004H .CRT$XIC                DATA
0003:00000010 00000004H .CRT$XIZ                DATA
0003:00000014 00000004H .CRT$XPA                DATA
0003:00000018 00000004H .CRT$XPZ                DATA
0003:0000001c 00000004H .CRT$XTA                DATA
0003:00000020 00000004H .CRT$XTZ                DATA
0003:00000030 00002490H .data                   DATA
0003:000024c0 000005fcH .bss                    DATA
0004:00000000 00000250H .rsrc$01                DATA
0004:00000250 00000720H .rsrc$02                DATA

After the section information, you get the public function information. Notice the "public" part. If you have static-declared C functions, they won't show up in the MAP file. Fortunately, the line numbers will still reflect the static functions. The important parts of the public function information are the function names and the information in the Rva+Base column, which is the starting address of the function.

Collapse

  Address         Publics by Value              Rva+Base     Lib:Object
0001:00000000       _WinMain@16                00401000 f   MAPFILE.obj
0001:000000c0       ?MyRegisterClass@@YAGPAUHINSTANCE__@@@Z 004010c0 f   MAPFILE.obj
0001:00000150       ?InitInstance@@YAHPAUHINSTANCE__@@H@Z 00401150 f   MAPFILE.obj
0001:000001b0       ?WndProc@@YGJPAUHWND__@@IIJ@Z 004011b0 f   MAPFILE.obj
0001:00000310       ?About@@YGJPAUHWND__@@IIJ@Z 00401310 f   MAPFILE.obj
0001:00000350       _WinMainCRTStartup         00401350 f   LIBC:wincrt0.obj
0001:00000446       __amsg_exit                00401446 f   LIBC:wincrt0.obj
0001:0000048f       __cinit                    0040148f f   LIBC:crt0dat.obj
0001:000004bc       _exit                      004014bc f   LIBC:crt0dat.obj
0001:000004cd       __exit                     004014cd f   LIBC:crt0dat.obj
0001:00000591       __XcptFilter               00401591 f   LIBC:winxfltr.obj
0001:00000715       __wincmdln                 00401715 f   LIBC:wincmdln.obj
//SNIPPED FOR BETTER READING
0003:00002ab4       __FPinit                   00408ab4     <common>
0003:00002ab8       __acmdln                   00408ab8     <common>
entry point at        0001:00000350
Static symbols
0001:000035d0       LeadUp1                    004045d0 f   LIBC:memmove.obj
0001:000035fc       LeadUp2                    004045fc f   LIBC:memmove.obj
//SNIPPED FOR BETTER READING
0001:00000577       __initterm                 00401577 f   LIBC:crt0dat.obj
0001:0000046b       _fast_error_exit           0040146b f   LIBC:wincrt0.obj

The public function part is followed by the line information (you got this if you used the /MAPINFO:LINES in the Link tab and selected the "Line numbers" in the C/C++ tab). After this, you will get the export information if your project contains exported functions and you included /MAPINFO:EXPORTS in the link tab.

Collapse

Line numbers for .\Release\MAPFILE.obj(F:\MAPFILE\MAPFILE.cpp) segment .text
24 0001:00000000    30 0001:00000004    31 0001:0000001b    32 0001:00000027
35 0001:0000002d    53 0001:00000041    40 0001:00000047    43 0001:00000050
45 0001:00000077    47 0001:00000088    48 0001:0000008f    52 0001:000000ad
53 0001:000000b3    71 0001:000000c0    80 0001:000000c3    81 0001:000000c8
82 0001:000000ff    86 0001:00000114    88 0001:00000135    89 0001:00000145
102 0001:00000150   108 0001:00000155   110 0001:00000188   122 0001:0000018d
115 0001:0000018e   116 0001:0000019a   119 0001:000001a1   121 0001:000001a8
122 0001:000001ae   135 0001:000001b0   143 0001:000001cc   172 0001:000001ee
175 0001:0000020d   149 0001:00000216   157 0001:0000022c   175 0001:00000248
154 0001:00000251   174 0001:0000025f   175 0001:00000261   151 0001:0000026a
174 0001:00000287   175 0001:00000289   161 0001:00000294   164 0001:000002a8
165 0001:000002b6   166 0001:000002d8   174 0001:000002e7   175 0001:000002e9
169 0001:000002f2   174 0001:000002fa   175 0001:000002fc   179 0001:00000310
186 0001:0000031e   193 0001:0000032e   194 0001:00000330   188 0001:00000333
183 0001:00000344   194 0001:00000349

Now we will look up where the crash occurred. First, we'll determine which function contains the crash address. Look in the "Rva+Base" column and search the first function with an address bigger than the crash address. The preceding entry in the MAP file is the function that had the crash. In our example our crash address is 0x004011a1. This is between 0x00401150 and 0x004011b0 so we know the crash function is ?InitInstance@@YAHPAUHINSTANCE__@@H@Z . Any function name that starts with a question mark is a C++ decorated name. To translate the name, pass it as a command-line parameter to the Platform SDK program UNDNAME.EXE (in the bin dir). You won't need to do this most of the time as you might figure it out just by looking at it (here: InitInstance() in MAPFILE.obj).

This is a big step for bug tracking. But it gets even better: we can find out on which line the crash occurred! We need to do some basic hexadecimal mathematics, so people whom can't do this without a calculator: now is the time to use it. The first step is the following calculation: crash_address - preferred_load_address - 0x1000
Addresses are offsets from the beginning of the first code section, se we need to do this calculation. Subtracting the preferred load address is logical, but why do we need to substract another 0x1000? The crash address is an offset from the beginning of the code section, but the first part of the binary isn't the code section! The first part of the binary is the Portable Executable (PE), which is 0x1000 bytes long. Mystery solved. In our example, this is: 0x004011a1 - 0x00400000 - 0x1000 = 0x1a1

Now it's time to look in the line information section of the MAP file. The lines are shown like this: 30 0001:00000004. The first number is the line number, the second number is the offset from the beginning of the code section in which this line occurred. If we want to look for our line number, we just have to do the same thing we did for the function: determine the first occurrence of a bigger offset than the one we just calculated. The crash occurred in the preceding entry. In our example: 0x1a1 is before 0x1a8. So our crash occurred on line 119 in MAPFILE.CPP.

Keeping track of MAP files

Each release had it's own MAP file. It's not a bad idea to include the MAP file with the exe distribution. This way, you can be certain you have the correct MAP file for this exe. You could keep every MAP file with every exe on your system, but we all know this might give some troubles later on. The MAP file doesn't contain any information you wouldn't want the user to see (unless maybe class and function names ?) . A user would have no use with it, but at least you can ask for the MAP file if you don't have a copy yourself.

class CTest
{
     /* 成员函数和成员数据 */
};

// . . . 代码

// 分配一个对象
CTest * pTest = new Test;
// 分配一个有十个对象的数组 (CTest 要有缺省构造函数（default constuctor）)
CTest * p10Tests = new Test[ 10];

虽然这种写法在大多数时候都工作得很好，但还是有些情况下使用new是很烦人的，比如当你想重新分配一个数组或者当你想在预分配的内存上构造一个对象的时候。

比如第一种情况，重新分配一个数组效率是很低的：

// 分配一个有10个对象的数组
CTest * pTests = new Test[ 10];
// . . .
// 假设现在我们需要11个对象
CTest * pNewTests = new Test[ 11];
// . . . 我们必须把原来的对象拷贝到新分配的内存中
for ( int i = 0; i < 10; i++)
    pNewTests[ i] = pTests[ i];
delete pTests;
pTests = pNewTests;

如果你想在预分配的内存上创建对象，用缺省的new操作符是行不通的。要解决这个问题，你可以用placement new构造。它允许你构造一个新对象到预分配的内存上：

// buffer 是一个void指针 (void *)
// 用方括号[] 括起来的部分是可选的
[CYourClass * pValue = ] new( buffer) CYourClass[( parameters)];

下面是一些例子：

#include <new>

class CTest
{
public:
    CTest()
    {}
    CTest( int)
    {}
    /* 代码*/
};

int main(int argc, char* argv[])
{
    // 由于这个例子的目的，我们不考虑内存对齐问题
    char strBuff[ sizeof( CTest) * 10 + 100];
    CTest * pBuffer = ( CTest *)strBuff;

    // 缺省构造
    CTest * pFirst = new(pBuffer) CTest;

    // 缺省构造
    CTest * pSecond = new(pBuffer + 1) CTest;
    
    // 带参数的构造；
    // 不理会返回的指针
    new(pBuffer + 2) CTest( 5);

    // 带参数的构造
    CTest * pFourth = new( pBuffer + 3) CTest( 10);

    // 缺省构造
    CTest * pFifth = new(pBuffer + 4) CTest();

    // 构造多个元素（缺省构造）
    CTest * pMultipleElements = new(pBuffer + 5) CTest[ 5];
    return 0;
}

当你有自己的内存缓冲区或者在你实现自己的内存分配策略的时候，placement new会很有用。事实上在STL中广泛使用了placement new来给容器分配内存；每个容器类都有一个模版参数说明了构造/析构对象时所用的分配器（allocator）。

在使用placement new的时候，你要记住以下几点：

• 加上头文件#include <new>
• 你可以用placement new构造一个数组中的元素。
• 要析构一个用placement new分配的对象，你应该手工调用析构函数（并不存在一个“placement delete”）。它的语法如下：

pFirst->~CTest();
pSecond->~CTest();
//  . . . 等等

输入您的搜索字词 提交搜索表单

1、动态确定类

在MFC中CObject::IsKindOf( const CRuntimeClass* pClass ) 利用CRuntimeClass来进行判定，如果你生成的类是以CObject为基础的，你可以使用该成员函数来判定。下面举一个例子来加深了解。

class CAge:public CObject

BOOL IsAge(CObject* pO)

{

    return pO->IsKindOf( RUNTIME_CLASS( CAge ) );

}

BOOL IsAge2(CAge* pO)

{

    return pO->IsKindOf( RUNTIME_CLASS( CAge ) );

}

void main(void)

{

    CObject a;

    CAge b;

    IsAge(&a);//return FALSE

    IsAge(&b);//return TRUE

    IsAge2((CAge*)&a);//return FALSE,避免强制转换带来的错误

}

2、生成类

CObject CRuntimeClass::CreateObject(void)可以产生一个类变量。作用和new类似，但在某些特殊场合有独特的作用。下面举一个例子来加深了解。

假定有以下几个类定义

class CWndA: public CWnd

class CWndB: public CWnd

function1()

{

    CRuntimeClass* pC=RUNTIME_CLASS( CWndA );

    CreateWnd(pC);

}

CWnd* CreateWnd(CRuntimeClass* pClass)

{

    return (CWnd*)pClass->CreateObject();

}

在上面例子中，CreateWnd返回的是CWnd* 其实它是一个CWndA*。你可以进行由父类到子类的强制转换而不必要担心出错。使用CRuntimeClass可以代替使用switch生产类实例的一些繁琐。（请好好想想它的用途，当你发现它的好处时，你一定会大吃一惊，M$使用宏来实现类的动态检测，如果谁有兴趣可以去看看MFC的源代码。）

注意：在类的定义中使用IMPLEMENT_DYNCREATE后方可生效。

输入您的搜索字词 提交搜索表单

• 打开Project settings对话框（可以通过快捷键ALT+F7打开，也可以通过IDE菜单Project/Settings打开)
• 选择C/C++页，Category中选择general ，则出现一个Debug Info下拉列表框，可供选择的调试信息 方式包括：
  　

•  
• 选择Link页，选中复选框"Generate Debug Info"，这个选项将使连接器把调试信息写进可执行文件和DLL
• 如果C/C++页中设置了Program Database以上的选项，则Link incrementally可以选择。选中这个选项，将使程序可以在上一次编译的基础上被编译（即增量编译），而不必每次都从头开始编译。

断点
断点是调试器设置的一个代码位置。当程序运行到断点时，程序中断执行，回到调试器。断点是 最常用的技巧。调试时，只有设置了断点并使程序回到调试器，才能对程序进行在线调试。

设置断点：可以通过下述方法设置一个断点。首先把光标移动到需要设置断点的代码行上，然后

• 按F9快捷键
• 弹出Breakpoints对话框，方法是按快捷键CTRL+B或ALT+F9，或者通过菜单Edit/Breakpoints打开。打开后点击Break at编辑框的右侧的箭头，选择 合适的位置信息。一般情况下，直接选择line xxx就足够了，如果想设置不是当前位置的断点，可以选择Advanced，然后填写函数、行号和可执行文件信息。

去掉断点：把光标移动到给定断点所在的行，再次按F9就可以取消断点。同前面所述，打开Breakpoints对话框后，也可以按照界面提示去掉断点。

条件断点：可以为断点设置一个条件，这样的断点称为条件断点。对于新加的断点，可以单击Conditions按钮，为断点设置一个表达式。当这个表达式发生改变时，程序就 被中断。底下设置包括“观察数组或者结构的元素个数”，似乎可以设置一个指针所指向的内存区的大小，但是我设置一个比较的值但是改动 范围之外的内存区似乎也导致断点起效。最后一个设置可以让程序先执行多少次然后才到达断点。

数据断点：数据断点只能在Breakpoints对话框中设置。选择“Data”页，就显示了设置数据断点的对话框。在编辑框中输入一个表达式，当这个 表达式的值发生变化时，数据断点就到达。一般情况下，这个表达式应该由运算符和全局变量构成，例如：在编辑框中输入 g_bFlag这个全局变量的名字，那么当程序中有g_bFlag= !g_bFlag时，程序就将停在这个语句处。

消息断点：VC也支持对Windows消息进行截获。他有两种方式进行截获：窗口消息处理函数和特定消息中断。
在Breakpoints对话框中选择Messages页，就可以设置消息断点。如果在上面那个对话框中写入消息处理函数的名字，那么 每次消息被这个函数处理，断点就到达（我觉得如果采用普通断点在这个函数中截获，效果应该一样）。如果在底下的下拉 列表框选择一个消息，则每次这种消息到达，程序就中断。

值
Watch
VC支持查看变量、表达式和内存的值。所有这些观察都必须是在断点中断的情况下进行。
观看变量的值最简单，当断点到达时，把光标移动到这个变量上，停留一会就可以看到变量的值。
VC提供一种被成为Watch的机制来观看变量和表达式的值。在断点状态下，在变量上单击右键，选择Quick Watch， 就弹出一个对话框，显示这个变量的值。
单击Debug工具条上的Watch按钮，就出现一个Watch视图（Watch1,Watch2,Watch3,Watch4），在该视图中输入变量或者表达式，就可以观察 变量或者表达式的值。注意：这个表达式不能有副作用，例如++运算符绝对禁止用于这个表达式中，因为这个运算符将修改变量的值，导致 软件的逻辑被破坏。

Memory
由于指针指向的数组，Watch只能显示第一个元素的值。为了显示数组的后续内容，或者要显示一片内存的内容，可以使用memory功能。在 Debug工具条上点memory按钮，就弹出一个对话框，在其中输入地址，就可以显示该地址指向的内存的内容。

Varibles
Debug工具条上的Varibles按钮弹出一个框，显示所有当前执行上下文中可见的变量的值。特别是当前指令涉及的变量，以红色显示。

寄存器
Debug工具条上的Reigsters按钮弹出一个框，显示当前的所有寄存器的值。

进程控制
VC允许被中断的程序继续运行、单步运行和运行到指定光标处，分别对应快捷键F5、F10/F11和CTRL+F10。各个快捷键功能如下：
　

Call Stack
调用堆栈反映了当前断点处函数是被那些函数按照什么顺序调用的。单击Debug工具条上的Call stack就显示Call Stack对话框。在CallStack对话框中显示了一个调用系列，最上面的是当前函数，往下依次是调用函数的上级函数。单击这些函数名可以跳到对应的函数中去。

其他调试手段
系统提供一系列特殊的函数或者宏来处理Debug版本相关的信息，如下：

关注
一个好的程序员不应该把所有的判断交给编译器和调试器，应该在程序中自己加以程序保护和错误定位，具体措施包括：

• 对于所有有返回值的函数，都应该检查返回值，除非你确信这个函数调用绝对不会出错，或者不关心它是否出错。
• 一些函数返回错误，需要用其他函数获得错误的具体信息。例如accept返回INVALID_SOCKET表示accept失败，为了查明 具体的失败原因，应该立刻用WSAGetLastError获得错误码，并针对性的解决问题。
• 有些函数通过异常机制抛出错误，应该用TRY-CATCH语句来检查错误
• 程序员对于能处理的错误，应该自己在底层处理，对于不能处理的，应该报告给用户让他们决定怎么处理。如果程序出了异常， 却不对返回值和其他机制返回的错误信息进行判断，只能是加大了找错误的难度。

另外：VC中要编制程序不应该一开始就写cpp/h文件，而应该首先创建一个合适的工程。因为只有这样，VC才能选择合适的编译、连接 选项。对于加入到工程中的cpp文件，应该检查是否在第一行显式的包含stdafx.h头文件，这是Microsoft Visual Studio为了加快编译 速度而设置的预编译头文件。在这个#include "stdafx.h"行前面的所有代码将被忽略，所以其他头文件应该在这一行后面被包含。
对于.c文件，由于不能包含stdafx.h，因此可以通过Project settings把它的预编译头设置为“不使用”，方法是：

• 弹出Project settings对话框
• 选择C/C++
• Category选择Precompilation Header
• 选择不使用预编译头。

输入您的搜索字词 提交搜索表单

显卡又称显示器适配卡，现在的显卡都是3D图形加速卡。它是是连接主机与显示器的接口卡。其作用是将主机的输出信息转换成字符、图形和颜色等信息，传送到显示器上显示。显示卡插在主板的ISA、PCI、AGP扩展插槽中，ISA显示卡现已基本淘汰。现在也有一些主板是集成显卡的。

每一块显示卡基本上都是由“显示主芯片”，“显示缓存”（简称显存），“BIOS”，数字模拟转换器（RAMDAC），“显卡的接口”以及卡上的电容、电阻等组成。多功能显卡还配备了视频输出以及输入，供特殊需要。随着技术的发展，目前大多数显卡都将RAMDAC集成到了主芯片了。

显示主芯片顾名思义，显示主芯片自然是显示卡的核心，如nVIDIA公司的TNT2、GeForce2、GeForce MX以及现在刚出现市场不久的GeForce 4。它们的主要任务就是处理系统输入的视频信息并将其进行构建、渲染等工作。显示主芯片的性能直接决定这显示卡性能的高低，不同的显示芯片，不论从内部结构还是其性能，都存在着差异，而其价格差别也很大。一般来说，越贵的显卡，性能自然越好。

显存

显示卡的主芯片在整个显示卡中的地位固然重要，但显存的大小与好坏也直接关系着显示卡的性能高低。
建议:买的一定要性能高的.不然的话就会出现画面流畅,卡,花屏 /等一些.
SDRAM是现在应用最广的显存，几乎市场上的显卡使用的都是SDRAM显存。SDRAM与早期产品的设计思路完全不同，它可以在一个时钟周期内进行数据的读写，从而节省了等待时间。SDRAM现在已经成为显存市场上的主导产品，这主要是因为其低廉的价格和较佳的性能.这种的不错哦.

输入您的搜索字词 提交搜索表单

class LockableObject

{

      public:

            LockableObject(){}

            virtual ~LockableObject(){}

            virtual void Lock() = 0;

            virtual void Unlock() = 0;

};

CriticalSection.h

#include "LockableObject.h"

#include <windows.h>

class CriticalSection : public LockableObject

{

      public:

            CriticalSection();

            virtual ~CriticalSection();

            virtual void Lock();

            virtual void Unlock();

      private:

            CRITICAL_SECTION mCriticalSection;

};

CriticalSection.cpp

#include "CriticalSection.h"

CriticalSection::CriticalSection()

{

      InitializeCriticalSection(&mCriticalSection);

}

CriticalSection::~CriticalSection()

{

      DeleteCriticalSection(&mCriticalSection);

}

void CriticalSection::Lock()

{

      EnterCriticalSection(&mCriticalSection);

}

void CriticalSection::Unlock()

{

      LeaveCriticalSection(&mCriticalSection);

}

Lock.h

#include "CriticalSection.h"

class Lock

{

      public:

            Lock(LockableObject* pLockable);

            ~Lock();

      private:

            LockableObject* mLockable;

};

Lock.cpp

#include "Lock.h"

Lock::Lock(LockableObject* pLockable)

{

      mLockable = pLockable;

      pLockable->Lock();

}

Lock::~Lock()

{

      mLockable->Unlock();

}

输入您的搜索字词 提交搜索表单

下载地址：http://dl.google.com/pinyin/GooglePinyinInstaller.exe

用了一下，感觉挺好用的，同志们有兴趣的话，也试试看吧。恩

聪明的谷歌拼音输入法五大特色：

·         智能组句：选词准确率高，能聪明地理解您的意图，短句长句都合适。

·         流行词汇：整合互联网上的流行词汇、热门搜索一网打尽，词组丰富强大。

·         网络同步：您可以将使用习惯和个人字典同步在 Google 帐号，一个跟您走的个性化输入法。

·         一键搜索：拼写输入的同时轻点一键即可快捷搜索。输入法结合搜索框一举两得。

·         英文提示：打英文时只需输入前几个字母，输入法自动提示您可能要找的单字。

输入您的搜索字词 提交搜索表单

选项

目的

@

指定响应文件

/?

列出编译器选项

/AI

指定在解析传递到 #using 指令的文件引用时搜索的目录

/arch

使用 SSE 或 SSE2 指令生成代码

/C

在预处理期间保留注释

/c

编译但不链接

/clr

启用 C++ 的托管扩展并产生在公共语言运行库上运行的输出文件

/D

定义常数和宏

/E

将预处理器输出复制到标准输出

/EH

指定异常处理模型

/EP

将预处理器输出复制到标准输出

/F

设置堆栈大小

/FA

创建列表文件

/Fa

设置列表文件名

/Fd

重命名程序数据库文件

/Fe

重命名可执行文件

/FI

预处理指定的包含文件

/Fm

创建映射文件

/Fo

创建对象文件

/Fp

指定预编译头文件名

/FR 字串3
/Fr

生成浏览器文件

/FU

强制使用文件名，就像它已被传递到 #using 指令一样

/Fx

将插入的代码与源文件合并

/G3

优化代码以优选 386 处理器。在 Visual C++ 5.0 中已经停用，编译器将忽略此选项

/G4

优化代码以优选 486 处理器。在 Visual C++ 5.0 中已经停用，编译器将忽略此选项

/G5

优化代码以优选 Pentium 处理器

/G6

优化代码以优选 Pentium Pro、Pentium II 和 Pentium III 处理器

/G7

针对 Pentium 4 或 Athlon 优化代码。

/GA

优化 Windows 应用程序的代码

/GB

与 /G6 等效；将 _M_IX86 的值设置为 600

/Gd

使用 __cdecl 调用约定

/Ge

激活堆栈探测

/GF

字串2

/Gf

启用字符串池

/GH

调用挂钩函数 _pexit

/Gh

调用挂钩函数 _penter

/GL

启用全程序优化

/Gm

启用最小重新生成

/GR

启用运行时类型信息 (RTTI)

/Gr

使用 __fastcall 调用约定

/GS

缓冲区安全检查

/Gs

控制堆栈探测

/GT

支持使用静态线程本地存储区分配的数据的纤程安全

/GX

启用同步异常处理

/Gy

启用函数级链接

/GZ

与 /RTC1 相同

/Gz

使用 __stdcall 调用约定

/H

限制外部（公共）名称的长度

/HELP

列出编译器选项

/I

在目录中搜索包含文件

/J

更改默认的 char 类型

/LD

创建动态链接库

/LDd

创建调试动态链接库

/link

将指定的选项传递给 LINK

/MD

使用 MSVCRT.lib 创建多线程 DLL

/MDd

使用 MSVCRTD.lib 创建调试多线程 DLL

/ML

使用 LIBC.lib 创建单线程可执行文件

/MLd

使用 LIBCD.lib 创建调试单线程可执行文件

/MT

使用 LIBCMT.lib 创建多线程可执行文件

/MTd

使用 LIBCMTD.lib 创建调试多线程可执行文件

/nologo

取消显示登录版权标志

/O1

创建小代码

/O2

创建快速代码

/Oa

假设没有别名

/Ob

控制内联展开

/Od

禁用优化

/Og

使用全局优化

/Oi

生成内部函数

/Op

改善浮点数一致性

/Os

代码大小优先

/Ot

代码速度优先

/Ow

假定在函数调用中使用别名

/Ox

使用最大优化 (/Ob2gity /Gs)

/Oy

省略框架指针

/QI0f

执行 Pentium 0x0f 错误修复

/QIfdiv

执行 Pentium FDIV 错误修复

/QIfist

当需要从浮点类型转换为整型时取消 _ftol

/P

将预处理器输出写入文件

/RTC

启用运行时错误检查

/showIncludes

在编译期间显示包含文件的列表

/Tc 字串5
/TC

指定 C 源文件

/Tp
/TP

指定 C++ 源文件

/U

移除预定义宏

/u

移除所有的预定义宏

/V

设置版本字符串

/vd

取消或启用隐藏的 vtordisp 类成员

/vmb

对指向成员的指针使用最佳的基

/vmg

对指向成员的指针使用完全一般性

/vmm

声明多重继承

/vms

声明单一继承

/vmv

声明虚拟继承

/W

设置警告等级

/w

禁用所有警告

/Wall

启用所有警告，包括默认情况下禁用的警告

/WL

在从命令行编译 C++ 源代码时启用错误信息和警告消息的单行诊断

/Wp64

检测 64 位可移植性问题

/X

忽略标准包含目录

/Y-

忽略当前生成中的所有其他预编译头编译器选项

/Yc

创建预编译头文件

/Yd

将完整的调试信息放在所有对象文件中

/Yl

创建调试库时插入 PCH 引用

/Yu

在生成期间使用预编译头文件

/YX

自动处理预编译头

/Z7

生成与 C 7.0 兼容的调试信息

/Za

禁用语言扩展

/Zc

在 /Ze 下指定标准行为

/Zd

生成行号

/Ze

启用语言扩展

/Zg

生成函数原型

/ZI

将调试信息包含在与“编辑并继续”兼容的程序数据库中

/Zi

生成完整的调试信息

/Zl

从 .obj 文件中移除默认库名

/Zm

指定预编译头内存分配限制

/Zp

封装结构成员

/Zs

只检查语法

输入您的搜索字词 提交搜索表单

Critical section（临界区）用来实现“排他性占有”。适用范围是单一进程的各线程之间。它是：

·         一个局部性对象，不是一个核心对象。

·         快速而有效率。

·         不能够同时有一个以上的critical section被等待。

·         无法侦测是否已被某个线程放弃。

Mutex

Mutex是一个核心对象，可以在不同的线程之间实现“排他性占有”，甚至几十那些现成分属不同进程。它是：

·         一个核心对象。

·         如果拥有mutex的那个线程结束，则会产生一个“abandoned”错误信息。

·         可以使用Wait…()等待一个mutex。

·         可以具名，因此可以被其他进程开启。

·         只能被拥有它的那个线程释放（released）。

Semaphore

Semaphore被用来追踪有限的资源。它是：

·         一个核心对象。

·         没有拥有者。

·         可以具名，因此可以被其他进程开启。

·         可以被任何一个线程释放（released）。

Event Object

Event object通常使用于overlapped I/O，或用来设计某些自定义的同步对象。它是：

·         一个核心对象。

·         完全在程序掌控之下。

·         适用于设计新的同步对象。

·         “要求苏醒”的请求并不会被储存起来，可能会遗失掉。

·         可以具名，因此可以被其他进程开启。

Interlocked Variable

如果Interlocked…()函数被使用于所谓的spin-lock，那么他们只是一种同步机制。所谓spin-lock是一种busy loop，被预期在极短时间内执行，所以有最小的额外负担（overhead）。系统核心偶尔会使用他们。除此之外，interlocked variables主要用于引用技术。他们：

·         允许对4字节的数值有些基本的同步操作，不需动用到critical section或mutex之类。

·         在SMP（Symmetric Multi-Processors）操作系统中亦可有效运作。

输入您的搜索字词 提交搜索表单

Event对象之所以有大用途，正是因为它的状态完全在你掌握之下。Mutexes和Semaphores就不一样了，他们的状态会因为诸如WaitForSingleObject()之类的函数调用而变化。所以，你可以精确告诉一个event对象做什么事情，以及什么时候去做。

Event对象被运用在多种类型的高级I/O操作中。Event对象也可以用来设计你自己的同步对象。

产生一个event对象，可以调用CreateEvent():

CreateEvent

The CreateEvent function creates a named or unnamed event object.

HANDLE CreateEvent(

    LPSECURITY_ATTRIBUTES lpEventAttributes, // pointer to security attributes 

    BOOL bManualReset,                // flag for manual-reset event

    BOOL bInitialState,     // flag for initial state

    LPCTSTR lpName          // pointer to event-object name 

   );

For Example:

hEvent = CreateEvent(NULL,TRUE,FALSE," Event");

其中bManualReset需要特别说明一下：

如为FALSE，表示这个event将在变成激发状态（因而唤醒一个线程）之后，自动重置（reset）为非激发状态。如果是TRUE，表示不会自动重置，必须靠程序操作（调用ResetEvent()）才能将激发状态的event重置为非激发状态。

Return Values

If the function succeeds, the return value is a handle to the event object. If the named event object existed before the function call, the GetLastError function returns ERROR_ALREADY_EXISTS. Otherwise, GetLastError returns zero.

If the function fails, the return value is NULL.

与Event相关的几个API函数：

SetEvent()，把event对象设为激发状态

ResetEvent()，把event对象设为非激发状态，Reset的意思是“设定为非激发状态”，而不是“重新设定为激发状态”

PulseEvent()，如果是一个Manual Reset Event：把event对象设为激发状态，唤醒“所有”等待中的线程，然后event恢复为非激发状态。如果是一个Auto Reset Event：把event对象设为激发状态，唤醒“一个”等待中的线程，然后event恢复为非激发状态

如果是automatic，那event总是处于非激发状态，所以按下ResetEvent不会产生什么效果。但按下SetEvent和PulseEvent会唤醒一个等待中的线程。

如果是manual，event对象可能是激发的，也可能是非激发，视上一次调用的是SetEvent()或ResetEvent()而定。按下SetEvent会使得每一个等待中的线程立刻苏醒。按下PulseEvent会使的目前等待中的所有线程苏醒过来（随后立刻又进入等待状态）。

侯杰大叔翻译的书也搞死我了！Sigh。感觉概念很模糊，看得我一头雾水，来来回回看了好几遍了，还不知道自己是不是已经懂了。5555555。可能是多线程搞得太少的原因吧。加油了。继续看。恩。

输入您的搜索字词 提交搜索表单

The InitializeCriticalSection function initializes a critical section object.

VOID InitializeCriticalSection(

    LPCRITICAL_SECTION lpCriticalSection                // address of critical section object 

   );         

 Parameters

lpCriticalSection

Points to the critical section object.

Return Values

This function does not return a value.

当你用毕 critical section 时，你必须调用 DeleteCriticalSection() 清除它。这个函数并没有“释放对象”的意义在里头，不要把它和 C++ 的 delete 运算符混淆了。

The DeleteCriticalSection function releases all resources used by an unowned critical section object.

VOID DeleteCriticalSection(

    LPCRITICAL_SECTION lpCriticalSection                // pointer to critical section object 

   );         

Parameters

lpCriticalSection

Points to the critical section object.

Return Values

This function does not return a value.

一旦 critical section 被初始化，每一个线程就可以进入其中——只要他通过了 EnterCriticalSection() 这一关：

The EnterCriticalSection function waits for ownership of the specified critical section object. The function returns when the calling thread is granted ownership.

VOID EnterCriticalSection(

    LPCRITICAL_SECTION lpCriticalSection                // pointer to critical section object 

   );         

Parameters

lpCriticalSection

Points to the critical section object.

Return Values

This function does not return a value.

当线程准备好离开 critical section 的时候，他必须调用 LeaveCriticalSection():

The LeaveCriticalSection function releases ownership of the specified critical section object.

VOID LeaveCriticalSection(

    LPCRITICAL_SECTION lpCriticalSection                // address of critical section object 

   );         

Parameters

lpCriticalSection

Points to the critical section object.

Return Values

This function does not return a value.

下面是一个很简单的使用例子，只是为了演示如何使用，没有其它目的：

#include <stdio.h>

#include <windows.h>

const int numThreads = 3;

//¶¨ÒåÒ»¸öcritical section±äÁ¿

CRITICAL_SECTION gCS;

DWORD WINAPI helloFunc(LPVOID pArg)

{

       //½øÈëcritical section

       EnterCriticalSection(&gCS);

       int num = (int) pArg;

       printf("Hello Thread %d\n", num);

       //Ïß³ÌÓñϣ¬¼ÇµÃµ÷Óô˺¯ÊıÀ뿪critical section¡££¨Enter**ÓëLeave**µÄÊıÁ¿ÒªÅä¶Ô£©

       LeaveCriticalSection(&gCS);

       return 0;

}

int main()

{     

       //³õʼ»¯critical section

       InitializeCriticalSection(&gCS);

       HANDLE hThread[numThreads];

       DWORD begin = GetTickCount();

       for (int i = 0; i < numThreads; i++)

       {

              hThread[i] = CreateThread(NULL, 0, helloFunc, (LPVOID)i, 0, NULL);

       }

       WaitForMultipleObjects(numThreads, hThread, TRUE, INFINITE);

       DWORD elapse = GetTickCount() - begin;

       printf("elapse time: %d\n", elapse);

       //ËùÓĞÏß³ÌÖ´ĞĞÍê±Ïºó£¬deleteµôcritical section

       DeleteCriticalSection(&gCS);

       return 0;

}

输入您的搜索字词 提交搜索表单

Thread 线程，当线程结束时，线程对象即被激发。当线程还在进行时，则对象处于未激发状态。

Process 进程，当进程结束时，进程对象即被激发。当进程还在进行时，则对象处于未激发状态。

Change Notification ，当一个特定的磁盘子目录中发生一件特别的变化时，此对象即被激发。此对象系由 FindFirstChangeNotification() 产生

Console Input ，当 console 窗口的输入缓冲区中有数据可用时，此对象将处于激发状态。 CreateFile （）和 GetStdFile （）两函数可以获得 console handle 。

Event ， Event 对象的状态直接受控于应用程序所使用的三个 Win32 函数： SetEvent （）， PulseEvent （）， ResetEvent （）。 CreateEvent （）和 OpenEvent （）都可以传回一个 event object handle 。 Event 对象的状态也可以被操作系统设定——如果使用于“ overlapped ”操作时。

Mutex ，如果 mutex 没有被任何线程拥有，他就是处于激发状态。一旦一个等待 mutex 的函数返回了， mutex 也就自动重置为未激发状态。 CreateMutex （）和 OpenMutex （）都可以获得一个 Mutext 的 handle 。

Semaphore ， Semaphore 有点像 mutex ，但他有个计数器，可以约束其拥有者（线程）的个数。当计数器内容大于 0 时， semaphore 处于激发状态，当计数器内容等于 0 时， semaphore 处于未激发状态。 CreateSemaphore （）和 OpenSemaphore （）可以传回一个 semaphore handle 。

输入您的搜索字词 提交搜索表单

Win32 核心对象清单：

·         进程 processes

·         线程 threads

·         文件 files

·         事件 events

·         信号量 semaphores

·         互斥器 mutexes

·         管道 pipes ，分为 named 和 anonymous 两种

Defines Who is doing What, When to do it, and How to reach a certain goal. 过程是产品成本、进度和质量的主要决定因素。软件过程的组成，五大元素：工件 / 产品，活动，里程碑，资源和角色，关系。

工件（ Artifact ），是指软件开发过程的中间或最后工作产品，包括：文档，模型，程序，数据，计划，报告等

活动，软件过程由多个活动组成。

里程碑，是特殊的活动，当时钟到达特定时间，就会触发里程碑检查本阶段的所有活动和工作是否按要求完成

资源，人是最重要的资源

软件生命周期模型

是软件生命周期的一个框架，规定了软件开发、运作和维护等所需的过程、活动和任务。又称软件开发模型。

线形顺序模型 waterfall model

增量式模型 incremental model

演化模型 evolutionary model （目前采用最广泛的模型）

o   原型 prototyping

o   螺旋模型 spiral model

o   并发开发模型 concurrent development model

特殊过程模型

o   基于构件的开发 Component-Based Development

o   形式化方法的模型 Formal Methods Model

o   面向侧面的软件开发 Aspect-Oriented Software Development

抢先式多任务（ preemptive multitasking ）操作系统能够强迫应用程序把 CPU 分享给其他人，程序员不需要什么额外的努力。虽然这个减少了程序员的工作，也不会因为某个程序拒绝分享 CPU 而造成其他程序 hang 住，但是它使得各个线程之间的执行顺序不可预测，从而导致了 race condition 等一系列问题。