对关注性能的程序开发人员而言，一个好的计时部件既是益友，也是良师。计时器既可以作为程序组件帮助程序员精确的控制程序进程，又是一件有力的调试武器，在有经验的程序员手里可以尽快的确定程序的性能瓶颈，或者对不同的算法作出有说服力的性能比较。   
    
  　　在Windows平台下，常用的计时器有两种，一种是timeGetTime多媒体计时器，它可以提供毫秒级的计时。但这个精度对很多应用场合而言还是太粗糙了。另一种是QueryPerformanceCount计数器，随系统的不同可以提供微秒级的计数。对于实时图形处理、多媒体数据流处理、或者实时系统构造的程序员，善用QueryPerformanceCount/QueryPerformanceFrequency是一项基本功。   
    
  　　本文要介绍的，是另一种直接利用Pentium   CPU内部时间戳进行计时的高精度计时手段。以下讨论主要得益于《Windows图形编程》一书，第   15页－17页，有兴趣的读者可以直接参考该书。关于RDTSC指令的详细讨论，可以参考Intel产品手册。本文仅仅作抛砖之用。   
  　　在   Intel   Pentium以上级别的CPU中，有一个称为“时间戳（Time   Stamp）”的部件，它以64位无符号整型数的格式，记录了自CPU上电以来所经过的时钟周期数。由于目前的CPU主频都非常高，因此这个部件可以达到纳秒级的计时精度。这个精确性是上述两种方法所无法比拟的。   
    
  　　在Pentium以上的CPU中，提供了一条机器指令RDTSC（Read   Time   Stamp   Counter）来读取这个时间戳的数字，并将其保存在EDX:EAX寄存器对中。由于EDX:EAX寄存器对恰好是Win32平台下C++语言保存函数返回值的寄存器，所以我们可以把这条指令看成是一个普通的函数调用。像这样：   
    
  inline   unsigned   __int64   GetCycleCount()   
  {   
    __asm   RDTSC   
  }   
    
  但是不行，因为RDTSC不被C++的内嵌汇编器直接支持，所以我们要用_emit伪指令直接嵌入该指令的机器码形式0X0F、0X31，如下：   
    
  inline   unsigned   __int64   GetCycleCount()   
  {   
    __asm   _emit   0x0F   
    __asm   _emit   0x31   
  }   
    
  以后在需要计数器的场合，可以像使用普通的Win32   API一样，调用两次GetCycleCount函数，比较两个返回值的差，像这样：   
    
  unsigned   long   t;   
  t   =   (unsigned   long)GetCycleCount();   
  //Do   Something   time-intensive   ...   
  t   -=   (unsigned   long)GetCycleCount();   
    
  　　《Windows图形编程》第15页编写了一个类，把这个计数器封装起来。有兴趣的读者可以去参考那个类的代码。作者为了更精确的定时，做了一点小小的改进，把执行RDTSC指令的时间，通过连续两次调用GetCycleCount函数计算出来并保存了起来，以后每次计时结束后，都从实际得到的计数中减掉这一小段时间，以得到更准确的计时数字。但我个人觉得这一点点改进意义不大。在我的机器上实测，这条指令大概花掉了几十到100多个周期，在   Celeron   800MHz的机器上，这不过是十分之一微秒的时间。对大多数应用来说，这点时间完全可以忽略不计；而对那些确实要精确到纳秒数量级的应用来说，这个补偿也过于粗糙了。   
    
  这个方法的优点是：   
    
  1.高精度。可以直接达到纳秒级的计时精度（在1GHz的CPU上每个时钟周期就是一纳秒），这是其他计时方法所难以企及的。   
    
  2.   成本低。timeGetTime   函数需要链接多媒体库winmm.lib，QueryPerformance*   函数根据MSDN的说明，需要硬件的支持（虽然我还没有见过不支持的机器）和KERNEL库的支持，所以二者都只能在Windows平台下使用（关于DOS平台下的高精度计时问题，可以参考《图形程序开发人员指南》，里面有关于控制定时器8253的详细说明）。但RDTSC指令是一条CPU指令，凡是i386平台下Pentium以上的机器均支持，甚至没有平台的限制（我相信i386版本UNIX和Linux下这个方法同样适用，但没有条件试验），而且函数调用的开销是最小的。   
    
  3.   具有和CPU主频直接对应的速率关系。一个计数相当于1/(CPU主频Hz数)秒，这样只要知道了CPU的主频，可以直接计算出时间。这和   QueryPerformanceCount不同，后者需要通过QueryPerformanceFrequency获取当前计数器每秒的计数次数才能换算成时间。   
    
  这个方法的缺点是：   
    
  1.现有的C/C++编译器多数不直接支持使用RDTSC指令，需要用直接嵌入机器码的方式编程，比较麻烦。   
    
  2.数据抖动比较厉害。其实对任何计量手段而言，精度和稳定性永远是一对矛盾。如果用低精度的timeGetTime来计时，基本上每次计时的结果都是相同的；而RDTSC指令每次结果都不一样，经常有几百甚至上千的差距。这是这种方法高精度本身固有的矛盾。   
    
  关于这个方法计时的最大长度，我们可以简单的用下列公式计算：   
    
  自CPU上电以来的秒数   =   RDTSC读出的周期数   /   CPU主频速率（Hz）   
    
  64位无符号整数所能表达的最大数字是1.8×10^19，在我的Celeron   800上可以计时大约700年（书中说可以在200MHz的Pentium上计时117年，这个数字不知道是怎么得出来的，与我的计算有出入）。无论如何，我们大可不必关心溢出的问题。   
    
  下面是几个小例子，简要比较了三种计时方法的用法与精度   
    
  //Timer1.cpp   使用了RDTSC指令的Timer类//KTimer类的定义可以参见《Windows图形编程》P15   
  //编译行：CL   Timer1.cpp   /link   USER32.lib   
  #include   &ltstdio.h>   
  #include   "KTimer.h"   
  main()   
  {   
    unsigned   t;   
    KTimer   timer;   
    timer.Start();   
    Sleep(1000);   
    t   =   timer.Stop();   
    printf("Lasting   Time:   %d\n",t);   
  }   
    
  //Timer2.cpp   使用了timeGetTime函数   
  //需包含&ltmmsys.h>，但由于Windows头文件错综复杂的关系   
  //简单包含&ltwindows.h>比较偷懒：）   
  //编译行：CL   timer2.cpp   /link   winmm.lib     
  #include   &ltwindows.h>   
  #include   &ltstdio.h>   
    
  main()   
  {   
    DWORD   t1,   t2;   
    t1   =   timeGetTime();   
    Sleep(1000);   
    t2   =   timeGetTime();   
    printf("Begin   Time:   %u\n",   t1);   
    printf("End   Time:   %u\n",   t2);   
    printf("Lasting   Time:   %u\n",(t2-t1));   
  }   
    
  //Timer3.cpp   使用了QueryPerformanceCounter函数   
  //编译行：CL   timer3.cpp   /link   KERNEl32.lib   
  #include   &ltwindows.h>   
  #include   &ltstdio.h>   
    
  main()   
  {   
    LARGE_INTEGER   t1,   t2,   tc;   
    QueryPerformanceFrequency(&tc);   
    printf("Frequency:   %u\n",   tc.QuadPart);   
    QueryPerformanceCounter(&t1);   
    Sleep(1000);   
    QueryPerformanceCounter(&t2);   
    printf("Begin   Time:   %u\n",   t1.QuadPart);   
    printf("End   Time:   %u\n",   t2.QuadPart);   
    printf("Lasting   Time:   %u\n",(   t2.QuadPart-   t1.QuadPart));   
  }   
    
  ////////////////////////////////////////////////   
  //以上三个示例程序都是测试1秒钟休眠所耗费的时间   
  file://测/试环境：Celeron   800MHz   /   256M   SDRAM       
  //                     Windows   2000   Professional   SP2   
  //                     Microsoft   Visual   C++   6.0   SP5   
  ////////////////////////////////////////////////   
    
  以下是Timer1的运行结果，使用的是高精度的RDTSC指令   
  Lasting   Time:   804586872   
    
  以下是Timer2的运行结果，使用的是最粗糙的timeGetTime   API   
  Begin   Time:   20254254   
  End   Time:   20255255   
  Lasting   Time:   1001   
    
  以下是Timer3的运行结果，使用的是QueryPerformanceCount   API   
  Frequency:   3579545   
  Begin   Time:   3804729124   
  End   Time:   3808298836   
  Lasting   Time:   3569712  

转自：http://blog.csdn.net/bbs598598/article/details/7441687

USES_CONVERSION是ATL中的一个宏定义。用于编码转换(用的比较多的是CString向LPCWSTR转换)。在ATL下使用要包含头文件#include "atlconv.h"

使用USES_CONVERSION一定要小心，它们从堆栈上分配内存，直到调用它的函数返回，该内存不会被释放。如果在一个循环中，这个宏被反复调用几万次，将不可避免的产生stackoverflow。

在一个函数的循环体中使用A2W等字符转换宏可能引起栈溢出。

让我们来分析以上的转换宏

关键的地方在 alloca  内存分配内存上。

_alloca
Allocates memory on the stack.

Remarks
_alloca allocates size bytes from the program stack. The allocated space is automatically freed when the calling function

exits. Therefore, do not pass the pointer value returned by _alloca as an argument to free.

问题就在这里，分配的内存是在函数的栈中分配的。而VC编译器默认的栈内存空间是2M。当在一个函数中循环调用它时就会不断的分配栈中的内存。

以上问题的解决办法：
1、自己写字符转换函数，不要偷懒

等等一个一个的实现。

2、把字符转换部分放到一个函数中处理。

如果不知道这点问题，在使用后崩溃时很难查出崩溃原因的。

这应该是模板元编程里的概念吧，有时候我们确实需要获取成员变量的类型，这里提供一个方法借助模板的偏特化达到目的：

假设我们有个结构定义如下：

通过 MemberType< decltype( &Call::ID ) >::member_type 就可以获得是变量 ID 的类型（int）了。

注：如果你的编译器不支持 decltype, 可以使用 boost 库里的 BOOST_TYPEOF 代替。

C++操作符的优先级

操作符及其结合性

功能

用法

下载源代码

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


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

void Crash1()

{

char * p =(char*)100;

*p=100;

}

#include 

void Crash2();

int main(int argc,char* argv[])

{

Crash2();

return 0;

}



void Crash2()

{

char p[1];

strcpy(p,"0123456789");

}

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

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

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

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 }

 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

...

	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

; 15   : {

00000	55		 push	 ebp

00018	c7 45 fc 64 00

00 00		 mov	 DWORD PTR _p$[ebp], 100	; 00000064H

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

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

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

; 17   :  *p=100;

产生如下错误：
1>e:\dgsource\dg_game\project2009\branches\alpha4\dreamgame\client\projects\gameclientshare\gamemoduleui.cpp(47): warning C4800: “IGameWorld *”: 将值强制为布尔值“true”或“false”(性能警告)

原因：GetGameWorld() 返回的 IGameWorld * 未定义；此前只是做了以下声明:

但未包含 IGameWorld 的头文件。

在文件开始处增加如下语句，警告消失：

一、C++标准异常

也就是try、throw、catch这三个关键字。

try
{
    ……
    throw <exception-data>
    ……
}

catch (<exception-declaration 1>)
{
    ……
}
catch (<exception-declaration 2>)
{
    ……
}
……

try块中的throw会抛出一个数据<exception-data>，比如一个整数，一个字串，或是其他自定义类型的数据。这时，当前程序中止执行，开始查找catch入口。throw抛出的数据类型与catch入口的<exception-declaration>数据类型必须匹配，这一点类似函数调用的形参、实参匹配。一个try块可以对应多个catch块，这一点类似于函数的重载。当然，你也可以用catch (…)来接收所有可能抛出的数据。MFC提供了一些标准的抛出异常类型，如CFileException类、CDaoException类等，它们都是CException类的派生类，使用MFC时可以了解一下，这里就不多说。

执行完catch块，程序会继续向下执行。

当throw在本函数（或说栈的本帧）没有找到合适的catch块时，会向上一层调用函数（或说栈的上一帧）回溯，直到匹配到合适的try-catch块为止。也就是说，try-catch块可以捕获到try块中调用(可以是多层调用)的函数中的，没被处理的异常。同时，try-catch块是可以嵌套的。

那么，有一个问题：没有try-catch块的，或查找到调用顶层（如main函数）都没有匹配上catch块的throw语句会如何执行呢？这在不同操作系统会有不同的处理，在Windows中则是由一个叫SEH的机制来处理的。

二、Windows SEH

SEH（Structured Exception Handling），即结构化异常处理，是Microsoft提供的异常处理机制。要了解这个机制，咱先来了解一下__try-__except关键字。

1. __try-__except关键字

__try
{
    ……
}

__except (<exception>)
{
    ……
}

__try-__except是Microsoft扩展出的C++关键字，__try块中出现错误或异常，一般不再用throw抛出，而是直接产生一个EXCEPTION_POINTERS类型的异常数据，然后开始查找SEH例程入口（调试的情况除外）。首先就会找到与__try块对应的__except块。__except的参数<exception>与catch的参数作用完全不同，也不类似于函数的参数，它主要是用于控制后面的程序执行，为这几个值之一：

EXCEPTION_EXECUTE_HANDLER（1），表示下面执行__except块内及其后面的代码
EXCEPTION_CONTINUE_EXECUTION（-1），表示回到抛出异常处继续向下执行
EXCEPTION_CONTINUE_SEARCH（0）, 表示查找下一个异常处理例程入口

Microsoft提供两个函数GetExceptionCode(), GetExceptionInformation()，分别可以获取异常号和EXCEPTION_POINTERS类型的异常数据指针。而且这两个函数只能在__except参数<exception>的表达式中使用。为了保证这一点，在Microsoft Visual C++（以下简称VC）中，编译器做了特殊处理，如果这两个函数没有在正确的位置，将产生编译错误。（这个感觉有点搞。）

所以，__except一行一般会这样写：__except (ExceptFilterFunc(GetExceptionInformation()))，其中ExceptFilterFunc是一个自定义的异常处理例程，它输入一个EXCEPTION_POINTERS *类型的参数，返回EXCEPTION_EXECUTE_HANDLER、EXCEPTION_CONTINUE_EXECUTION或EXCEPTION_CONTINUE_SEARCH。

（注：下面所提到的“异常处理例程”，不管是自定义的还是系统提供的，都是这种类型的函数，这种函数指针类型在winbase.h中被定义为LPTOP_LEVEL_EXCEPTION_FILTER。）

EXCEPTION_POINTERS结构中包含丰富的异常相关数据，主要有异常号、异常发生时寄存器的值等。

与try-catch一样，__try-__except也支持调用栈回溯，也可以嵌套，但没法重载。

另外，在VC中，还提供__try-__finally块和__leave关键字，这里不细说了，感兴趣的可以查查MSDN。

2. Windows异常处理步骤

回到上文的问题，没有匹配上catch、__except块的错误或异常将会如何处理呢？原来，包括__except块在内，SEH异常处理例程可以有多个，它们的入口地址形成一个链式结构，这个链式结构由Windows操作系统管理。

发生错误或异常后，Windows的处理顺序一般如下：

（1）中止当前程序的执行。

（2）如果程序处于被调试状态，向调试器发送EXCEPTION_DEBUG_EVENT消息。

（3）如果程序没有被调试或者调试器未能处理异常，查找线程相关的异常处理例程（如对应__except块）并处理。如果前面查找到的例程返回EXCEPTION_CONTINUE_SEARCH，且线程有多个异常处理例程，则沿这些例程入口地址组成的链式结构逐一向后查找，请求下一个例程处理。

（4）如果线程没有对应的异常处理例程，或线程所有例程都返回EXCEPTION_CONTINUE_SEARCH，而且程序处于被调试状态，再次通知调试器。

（5）如果程序没有被调试或者调试器仍未处理异常，则进入主线程的“最终异常处理例程”链继续查找。

（6）“最终异常处理例程”链的最后是Windows默认的系统异常处理程序__CxxUnhandledExceptionFilter()，其处理通常是弹出一个异常对话框，上面显示一些异常信息，提供“关闭”、“调试”等按钮。

著名的SetUnhandledExceptionFilter()函数就是在所谓“最终异常处理例程”链的__CxxUnhandledExceptionFilter()之前插入一个自定义的异常处理例程，当这个例程返回EXCEPTION_EXECUTE_HANDLER时，一般会直接结束进程。

三、两种异常处理机制的比较

我能想到的一些特征的比较：

	C++标准异常	SEH
局部对象析构函数	执行	局部对象有析构函数，且用__try-__exception时，编译错误
可重载	有参数类型匹配	无条件处理
可移植	C++都有，不依赖操作系统平台	只有Windows提供
程序流程控制	catch块后只能继续向下执行	EXCEPTION_EXECUTE_HANDLER、EXCEPTION_CONTINUE_EXECUTION、 EXCEPTION_CONTINUE_SEARCH三种流程控制，多个处理例程的依次处理
数据通用	各种不同的异常数据类型	统一结构的异常数据

四、VC编译参数EH

在VC中，你可能会发现一个怪异的现象，就是try-catch块无法捕获像“除0”、“空指针访问”之类的异常。原来，在VC中一般的错误和异常都是用SEH来处理的，不等同于throw抛出的异常。而try-catch对结构化异常的处理，是由编译参数EH来控制的。

	无EH参数	EHs(EHsc)	EHa(同Ehac)
try-catch	不处理异常	只处理C++标准异常，代码优化较好	处理C++标准异常和结构化异常，代码优化较差
__try-__except（VC2005及以后）	处理C++标准异常和结构化异常	处理C++标准异常和结构化异常	处理C++标准异常和结构化异常
__try-__except（VC2003及以前）	只处理结构化异常	只处理结构化异常	只处理结构化异常

从表中可以看出，EH参数对__try-__except块的处理并无影响。

从VC2005开始，SEH也可以统一捕获和处理C++标准异常。而在VC2003及之前，C++标准异常只能由catch块来捕获。

VC2005中，EH参数默认为EHsc。

附记：关于自定义SEH异常处例程的编写，如保存内存dump，保存调用栈，使用调试相关的.pdb .map文件等，网上相关的资料很多，需要可以查询。

from devdiv.net

打开VC工程后，菜单：Debug-->exceptions

然后选择需要中断的异常


程序异常（这里以除0为例）
IDE自动断在错误代码处：

    针对这部分功能，微软提供给开发者一个自定义接口，就是通过修改autoexp.dat这个看起来其貌不扬的小文件，该文件放在“$(VSINSTALLDIR)\Common7\Packages\Debugger”目录下，微软并没有提供关于这个文件的说明文档，只是在这个文件开始的地方有一些简单的说明，好在这个文件的结构并不复杂，通过分析现成的例子，大概也能了解个八九不离十。
    先以一个例子说明如何使用这个文件，打开这个文件，在”[Visualizer]“这一行下面添加下面的内容

    然后启动VC, 随便定义一个名字为MyClass的类，当使用VC的调试器查看这个类的内容时，你会发现显示的调试内容已经变成了”Hello,World!”


    下面我们再来看一个稍微复杂的例子，比如一个自定义的数组类

    调试这个数据结构的时候，我们想显示这个数组的元素个数，每个元素的值，以及每个元素的奇偶性，那么需要这样定义:

    实际显示效果为:

    其中，$c表示当前所定义数据结构，#array表示用数组形式显示内容，$i表示数组中的每个元素的索引，$e表示每个元素的值，同样，可以用#tree和#list分别用来显示树形数据结构和链表类型的数据结构。
    autoexp.dat中已经对VC提供的缺省的STL数据结构做了定义，比如vector,map等，通过分析这些定义，还可以挖出很多有趣的功能，比如用#if/#else/#switch/#case等条件判断功能，在处理一些比较复杂的组合类型的数据结构时，就非常有用。
    下面是一份我制作的，针对另一份较为常用的STL库STLPORT 中部分数据结构的定义，适应STLPORT 5.2版本，使用方法是将其中的内容拷贝到autoexp.dat的”[Visualizer]“段中，大家有兴趣的话可以拿去使用，如果发现错误或者有补充的话，请通知我。

下载: autoexp.dat (1.2K)

转自：http://www.thecodeway.com/blog/?p=924#more-924

类型double大小为8字节，即64位，内存布局如下：
符号位（1 bit） 指数（11 bit） 尾数（52 bit）

 
符号位决定浮点数的正负，0正1负。
指数和尾数均从浮点数的二进制科学计数形式中获取。
如，十进制浮点数2.5的二进制形式为10.1，转换为科学计数法形式为(1.01)*(10^1)，由此可知指数为1，尾数（即科学计数法的小数部分）为01。
根据浮点数的存储标准（IEEE制定），float类型指数的起始数为127（二进制0111 1111），double类型指数的起始数为1023(二进制011 1111 1111)，在此基础上加指数，得到的就是内存中指数的表示形式。尾数则直接填入，如果空间多余则以0补齐，如果空间不够则0舍1入。所以float和double类型分别表示的2.5如下（二进制）：
符号位 指数 尾数
0 1000 0000 010 0000 0000 0000 0000 0000
0 100 0000 0000 0100 0000 0000 0000 0000 0000 0000
0000 0000 0000 0000 0000 0000

浮点数2.5可以用二进制小数准确表示（2.5=1*(2^1)+0*(2^0)+1*(2^-1)），但很多小数不可以准确表示，其二进制形式的小数部分会无限循环，如浮点数-1.2表示如下（二进制）：
符号位 指数 尾数
1 0111 1111 0011 0011 0011 0011 0011 010
1 011 1111 1111 0011 0011 0011 0011 0011 0011 0011
0011 0011 0011 0011 0011 0011

由于对无限循环尾数的截取遵循0舍1入，尾数的第21~24位为0011，第53~56位为0011，而float尾数容量为23位，double尾数容量为52位，所以，float形式的最后三位因进位而成010，double形式则没有进位发生。
 
类型float和double通过==,>,<等比较不会引起编译错误，但是非常可能得到错误的结果。这是因为它们的内存分布不同，不可以直接比较。正确的方法是转换为同一类型后比较两者差值，如果结果小于规定的小值，则视为相等。
如，一个比较double的实现：
http://metasharp.net/index.php?title=How_to_compare_double_or_float_in_Cpp
另外，本文参考了如下webs：
http://cdatatype.blogspot.com/2008/01/memory-map-of-floatdouble.html
http://blog.csdn.net/hzb1983/archive/2007/09/24/1798555.aspx
 
P.S.
1)
IEEE浮点数标准：     4字节浮点数：1位符号位，8位阶数（基数为127的移码），23位尾数；     8字节浮点数：1位符号位，11位阶数（基数为1023的移码），52位尾数
2 )
在VC中： float数值范围约在 -10e38~10e38，并提供7位有效数字位，绝对值小于10e38地数被处理成零值 double数值范围约在-10e308~10e308，并提供15~16位有效数字，绝对值小于10e308地数被处理成零值

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/vinsendai/archive/2008/06/27/2593035.aspx

Replace the VS 2010 help viewer or run stand-alone. The viewer is free for personal use. Contact us if you need to distribute it.

See the H3Viewer Home Page 

Features:

• Similar experience to VS 2005\2008 DExplore.
• Full TOC with TOC Sync.
• Full Index. Two modes: Both VS 2010 and DExplore type experience.
• Text-to-Speech reader.
• Full bookmark support.
• Set default viewer for VS 2010.
• Option: Open F1 help in a new page tab.
• View different MSDN language catalogs.
• UI Translations available (see below).
• Direct link to equivalent MSDN online page.
• Open current page in selected browser.
• etc.

Build 54 adds Czeck & Swedish to the GUI Language packs

• Czech -- Translated by Martin Šojdr, www.sojdr.com
• German -- Translated by Ulrich Kulle [MVP 2007-2009], www.help-info.de
• Hebrew -- Translated by Ishai Sagi [MVP], www.sharepoint-tips.com
• Italian -- Translated by Alessandro Del Sole [MVP], www.visual-basic.it
• Japanese - Translated by Tomohiro Takano
• Polish -- Translated by Piotr Strycharz, www.computerplus.pl
• Simplified Chinese -- Translated by Hu Hsiaotao
• Swedish -- Translated by Tobias Moberg, www.carmenta.com

• Don't see your language? Help us translate. It's easy.

Note to user Nofb: I've also added a check for "MS Help Viewer Power Toy Beta" as requested. In future I'd prefer you contact me directly or use Q & A section. Writing complaints in the review tab is a one way conversation. I could have quickly told you that there was a known problem with the MS Beta and to check the online documentation. Thanks!

Known Issues

• Application Freezes
  The embedded browser is Internet Explorer. On some systems after a few successful clicks the application seems to hang. Try clearing the IE cache, resetting IE settings, and removing 3rd-party IE add-ons you don't use. (all I can say is bring on IE9)
• Pages without style & broken links 
  If you find pages are not showing style correctly and some links are not working then it probably means you have the Help Viewer power toy Beta installed. Uninstall this and it will immediately return to normal. Also remember to stop the Agent tray application.

Screen Shots

Notice the pink folder, which is an orphan help branch not attached to the main VS 2010 TOC. The TOC Sync command will add orphans if found.

Inline Index disambiguator. Load full Index (VS 2008 style) or partial load as you type index (VS 2010 style).

Full bookmark support for Help Viewer URLs.

Here we've downloaded Russian help (vs\100\ru) using VSHelpDownloader. Press F1 in VS 2010 to display the topic in whatever language is loaded.