这里所说的VC下的错误对话框时指在VC中开调试器运行程序时，IDE弹出的对话框。

1.不是错误的错误：断言 .

将断言视为错误其实有点可笑，但是因为有些同学甚至不知道这个，所以我稍微提一下。断言对话框大致上类似于：

断言对话框是由assert引起的，在对话框上通常会给出表达式，例如assert( 0 ); 弹出对话框时就会将0这个表达式显示出来（Expression:0)。关于assert的具体信息建议自己google。这里稍微提一下一个技巧：有时候为了让assert提供更多的信息，我们可以这样写一个assert:

assert( expression && "Function : invalid argument!" );

因为字符串被用在布尔表达式中时，始终为true，不会妨碍对expression的判断，当断言发生时(expression为false) 时，断言对话框上就会显示这个字符串，从而方便我们调试。

要解决这个问题，首先要确定断言发生的位置，如果是你自己设置的断言被引发，就很好解决，如果是系统内部的函数产生的，那么一般是因为你传入的函数参数无效引起。

2.内存相关：最简单的非法访问：

C、C++程序中经常误用无效的指针，从而大致各种各样的非法内存访问（写/读）。最简单的情况类似于：

这样的情况由类似以下代码引起：

char *p = 0;

*p = 'a';

当你看到类似于“写入位置XXXX时发生访问冲突“时，那么你大致可以断定，你的程序在某个地方访问到非法内存。开调试器对调用堆栈进行跟踪即可找出错误。

3.内存相关：不小心的栈上数组越界：

当你写下类似以下的代码时：

char str[3];

strcpy( str, "abc" );

就将看到如下的对话框：

对话框大致的意思就是说str周围的栈被破坏了，因为str本身就被放在栈上，所以strcpy(str,"abc")多写入的'\0'就写到非法的栈区域。看到这样的对话框可以根据调用堆栈定位到错误发生的函数，然后检查此函数内部定义的数组访问，即可解决问题。

4.内存相关：不小心的堆上数组越界：
并不是每次数组越界都会得到上面所描述的错误，当数组是在堆上分配时，情况就变得隐秘得多：

char *str = new char [2];

strcpy( str, "ab" ); //执行到这里时并不见得会崩溃

delete [] str;//但是到这里时就肯定会崩溃

以上代码导致的错误对话框还要诡异些：

似乎不同的DAMAGE对应的错误号（这里是47）都不一样，因为这里的错误发生在delete，而delete跟new很可能在不同的地方，所以这个错误调试起来不是那么容易，很多时候只能靠经验。

当看到类似的对话框时，根据调用堆栈跟到delete时，你就可以大致怀疑堆上数组越界。

5.调用相关：函数调用约定带来的错误：

这是所有我这里描述的错误中最诡异的一种，先看下对话框大致的样子：

对话框大致的意思就是说（没开调试器时对话框样式可能不一样），通过函数指针调用某个函数时，函数指针的类型（函数原型）可能与函数指针指向的函数的类型不一样。这里的类型不一致主要是调用约定(call conversation）不一样。如果函数类型（参数个数，返回值）不一样，一般不会出错。

调用约定是指调用一个函数时，函数参数的压入顺序、谁来清理栈的内容等。例如默认的C、C++调用约定__cdecl，对于函数的参数是从右往左压入。而__stdcall（WIN API的调用约定）则是从左向右压。我这里所说的函数类型不一样，就是指一个函数是使用__cdecl，还是__stdcall。例如以下代码：

#include <iostream> 

void __stdcall show( const char *str ) 

{ 

} 

void __stdcall show2() 

{ 

} 

int main() 

{ 

typedef void (*Func)( const char *); 

void *p = show; 

Func my_func = (Func) p; 

my_func( "kevin" ); 

return 0; 

} 

因为Func默认地被处理为__cdecl，而show是__stdcall的，所以当通过函数指针my_func时，就导致了以上对话框的出现。但是当p指向show2时，又不会出错，这是因为show2没有参数，不同的调用约定不影响这个规则。

6.异常相关：默认终止程序

当我们使用C++库时，因为库本身可能会抛出C++异常，如果你不捕获这个异常，那么C++默认就会调用abort（或者exit）函数终止程序。例如：

void test()
{
    throw std::exception( "some exceptions" );
}

当你调用test函数时，如果不catch这个异常，开调试器就会得到类似的错误对话框：

而如果不开调试器，则会得到：

当你看到类似于“This application has requested the Runtime to terminate it…”之类的字眼时，那就表明程序调用了abort（或exit）函数，导致程序异常终止。其实这个错误只要开调试器，一般可以准确定位错误的发生点。

众多C++书籍都忠告我们C语言宏是万恶之首，但事情总不如我们想象的那么坏，就如同goto一样。宏有
一个很大的作用，就是自动为我们产生代码。如果说模板可以为我们产生各种型别的代码(型别替换)，
那么宏其实可以为我们在符号上产生新的代码(即符号替换、增加)。

关于宏的一些语法问题，可以在google上找到。相信我，你对于宏的了解绝对没你想象的那么多。如果你
还不知道#和##，也不知道prescan，那么你肯定对宏的了解不够。

我稍微讲解下宏的一些语法问题(说语法问题似乎不妥，macro只与preprocessor有关，跟语义分析又无关)：

1. 宏可以像函数一样被定义，例如：
   #define min(x,y) (x<y?x:y) //事实上这个宏存在BUG
   但是在实际使用时，只有当写上min()，必须加括号，min才会被作为宏展开，否则不做任何处理。
  
2. 如果宏需要参数，你可以不传，编译器会给你警告(宏参数不够)，但是这会导致错误。如C++书籍中所描
   述的，编译器(预处理器)对宏的语法检查不够，所以更多的检查性工作得你自己来做。

3. 很多程序员不知道的#和##
   #符号把一个符号直接转换为字符串，例如：
   #define STRING(x) #x
   const char *str = STRING( test_string ); str的内容就是"test_string"，也就是说#会把其后的符号
   直接加上双引号。
   ##符号会连接两个符号，从而产生新的符号(词法层次)，例如：
   #define SIGN( x ) INT_##x
   int SIGN( 1 ); 宏被展开后将成为：int INT_1;

4. 变参宏，这个比较酷，它使得你可以定义类似的宏：
   #define LOG( format, ... ) printf( format, __VA_ARGS__ )
   LOG( "%s %d", str, count );
   __VA_ARGS__是系统预定义宏，被自动替换为参数列表。

5. 当一个宏自己调用自己时，会发生什么？例如：
   #define TEST( x ) ( x + TEST( x ) )
   TEST( 1 ); 会发生什么？为了防止无限制递归展开，语法规定，当一个宏遇到自己时，就停止展开，也就是
   说，当对TEST( 1 )进行展开时，展开过程中又发现了一个TEST，那么就将这个TEST当作一般的符号。TEST(1)
   最终被展开为：1 + TEST( 1) 。

6. 宏参数的prescan，
   当一个宏参数被放进宏体时，这个宏参数会首先被全部展开(有例外，见下文)。当展开后的宏参数被放进宏体时，
   预处理器对新展开的宏体进行第二次扫描，并继续展开。例如：
   #define PARAM( x ) x
   #define ADDPARAM( x ) INT_##x
   PARAM( ADDPARAM( 1 ) );
   因为ADDPARAM( 1 ) 是作为PARAM的宏参数，所以先将ADDPARAM( 1 )展开为INT_1，然后再将INT_1放进PARAM。
  
   例外情况是，如果PARAM宏里对宏参数使用了#或##，那么宏参数不会被展开：
   #define PARAM( x ) #x
   #define ADDPARAM( x ) INT_##x
   PARAM( ADDPARAM( 1 ) ); 将被展开为"ADDPARAM( 1 )"。

   使用这么一个规则，可以创建一个很有趣的技术：打印出一个宏被展开后的样子，这样可以方便你分析代码：
   #define TO_STRING( x ) TO_STRING1( x )
   #define TO_STRING1( x ) #x
   TO_STRING首先会将x全部展开(如果x也是一个宏的话)，然后再传给TO_STRING1转换为字符串，现在你可以这样：
   const char *str = TO_STRING( PARAM( ADDPARAM( 1 ) ) );去一探PARAM展开后的样子。

7. 一个很重要的补充：就像我在第一点说的那样，如果一个像函数的宏在使用时没有出现括号，那么预处理器只是
   将这个宏作为一般的符号处理(那就是不处理)。

我们来见识一下宏是如何帮助我们自动产生代码的。如我所说，宏是在符号层次产生代码。我在分析Boost.Function
模块时，因为它使用了大量的宏(宏嵌套，再嵌套)，导致我压根没看明白代码。后来发现了一个小型的模板库ttl，说的
是开发一些小型组件去取代部分Boost(这是一个好理由，因为Boost确实太大)。同样，这个库也包含了一个function库。
这里的function也就是我之前提到的functor。ttl.function库里为了自动产生很多类似的代码，使用了一个宏：

#define TTL_FUNC_BUILD_FUNCTOR_CALLER(n)  \
 template< typename R, TTL_TPARAMS(n) > \
 struct functor_caller_base##n \
        ///...
该宏的最终目的是：通过类似于TTL_FUNC_BUILD_FUNCTOR_CALLER(1)的调用方式，自动产生很多functor_caller_base模板：
template <typename R, typename T1> struct functor_caller_base1
template <typename R, typename T1, typename T2> struct functor_caller_base2
template <typename R, typename T1, typename T2, typename T3> struct functor_caller_base3
///...
那么，核心部分在于TTL_TPARAMS(n)这个宏，可以看出这个宏最终产生的是：
typename T1
typename T1, typename T2
typename T1, typename T2, typename T3
///...
我们不妨分析TTL_TPARAMS(n)的整个过程。分析宏主要把握我以上提到的一些要点即可。以下过程我建议你翻着ttl的代码，
相关代码文件：function.hpp, macro_params.hpp, macro_repeat.hpp, macro_misc.hpp, macro_counter.hpp。

so, here we go

分析过程，逐层分析，逐层展开，例如TTL_TPARAMS(1)：

#define TTL_TPARAMS(n) TTL_TPARAMSX(n,T) 
=> TTL_TPARAMSX( 1, T )
#define TTL_TPARAMSX(n,t) TTL_REPEAT(n, TTL_TPARAM, TTL_TPARAM_END, t)
=> TTL_REPEAT( 1, TTL_TPARAM, TTL_TPARAM_END, T )
#define TTL_TPARAM(n,t) typename t##n,
#define TTL_TPARAM_END(n,t) typename t##n
#define TTL_REPEAT(n, m, l, p) TTL_APPEND(TTL_REPEAT_, TTL_DEC(n))(m,l,p) TTL_APPEND(TTL_LAST_REPEAT_,n)(l,p)
注意，TTL_TPARAM, TTL_TPARAM_END虽然也是两个宏，他们被作为TTL_REPEAT宏的参数，按照prescan规则，似乎应该先将
这两个宏展开再传给TTL_REPEAT。但是，如同我在前面重点提到的，这两个宏是function-like macro，使用时需要加括号，
如果没加括号，则不当作宏处理。因此，展开TTL_REPEAT时，应该为：
=> TTL_APPEND( TTL_REPEAT_, TTL_DEC(1))(TTL_TPARAM,TTL_TPARAM_END,T) TTL_APPEND( TTL_LAST_REPEAT_,1)(
TTL_TPARAM_END,T)
这个宏体看起来很复杂，仔细分析下，可以分为两部分：
TTL_APPEND( TTL_REPEAT_, TTL_DEC(1))(TTL_TPARAM,TTL_TPARAM_END,T)以及
TTL_APPEND( TTL_LAST_REPEAT_,1)(TTL_TPARAM_END,T)
先分析第一部分：
#define TTL_APPEND( x, y ) TTL_APPEND1(x,y) //先展开x,y再将x,y连接起来
#define TTL_APPEND1( x, y ) x ## y
#define TTL_DEC(n) TTL_APPEND(TTL_CNTDEC_, n)
根据先展开参数的原则，会先展开TTL_DEC(1)
=> TTL_APPEND(TTL_CNTDEC_,1) => TTL_CNTDEC_1
#define TTL_CNTDEC_1 0  注意，TTL_CNTDEC_不是宏，TTL_CNTDEC_1是一个宏。
=> 0 ， 也就是说，TTL_DEC(1)最终被展开为0。回到TTL_APPEND部分：
=> TTL_REPEAT_0 (TTL_TPARAM,TTL_TPARAM_END,T)
#define TTL_REPEAT_0(m,l,p)
TTL_REPEAT_0这个宏为空，那么，上面说的第一部分被忽略，现在只剩下第二部分：
TTL_APPEND( TTL_LAST_REPEAT_,1)(TTL_TPARAM_END,T)
=> TTL_LAST_REPEAT_1 (TTL_TPARAM_END,T) // TTL_APPEND将TTL_LAST_REPEAT_和1合并起来
#define TTL_LAST_REPEAT_1(m,p) m(1,p)
=> TTL_TPARAM_END( 1, T )
#define TTL_TPARAM_END(n,t) typename t##n
=> typename T1  展开完毕。

虽然我们分析出来了，但是这其实并不是我们想要的。我们应该从那些宏里去获取作者关于宏的编程思想。很好地使用宏
看上去似乎是一些偏门的奇技淫巧，但是他确实可以让我们编码更自动化。

参考资料：
macro语法: http://developer.apple.com/documentation/DeveloperTools/gcc-4.0.1/cpp/Macros.html
ttl(tiny template library) : http://tinytl.sourceforge.net/

base functor包括: unary_function, binary_function,分别表示只有一个参数的函数和有两个参数
的函数。实际上STL里还有一个所谓的generator，代表没有参数的函数。因为STL泛型算法一般最多
只会使用两个参数的函数，所以这里并没有定义更多参数的base functor。

可被functor adaptor使用的functor又称为adaptable function，根据参数的个数，会被命名为诸如
adaptable unary function, adaptable binary function。

一个返回值为bool的functor又被称为predicate，可被用于functor adaptor的predicate被称为
adaptable predicate。其实所谓的adaptable，只需要在类型内部typedef一些类型即可，一般包括
first_argument_type, second_argument_type, result_type。functor adaptor会使用这些定义。

预定义的functors都是些很简单的functor，基本上就是封装诸如plus, minus, equal_to之类的算术
运算，列举一个predefined functor的代码：
 

template <class _Tp>
  struct plus : public binary_function<_Tp, _Tp, _Tp>
  {
     _Tp operator()(const _Tp& __x, const _Tp& __y) const   
     { 
         return __x + __y; 
     }    
  };

因为从binary_function(即我所谓的base functor)派生，因此这些predefined functor也是adaptable
function。

functor adaptors里有很多有趣的东西，其实functor adaptor也是一些functor(从SGI的观点来看，一般
的C函数，函数指针都算作functor)。所不同的是，他们通常会适配(adapt)一种functor到另一种。例如：
std::binder1st，严格地说它是一个函数模板，它会把一个adaptable binary function转换为一个
adaptable unary function，并绑定一个参数。又如: std::ptr_fun，它会将一个只有一个参数的C函数
适配成一个pointer_to_unary_function的functor。

下面列举一些具体的代码：
关于base functor，基本上就只有unary_function, binary_function :
 

template <class _Arg, class _Result>
  struct unary_function
  {
      typedef _Arg argument_type;                    
      typedef _Result result_type; 
  };
  

关于predefined functor，如之前列举的plus一样，再列举一个：

template <class _Tp>
 struct greater : public binary_function<_Tp, _Tp, bool>
 {      
     bool operator()(const _Tp& __x, const _Tp& __y) const
     { 
         return __x > __y; 
     }    
 };

 
关于functor adaptors，也是我觉得比较有趣的部分，多列举几个：

template <class _Operation, class _Tp>
  inline binder1st<_Operation>
  bind1st(const _Operation& __fn, const _Tp& __x)
  {
      typedef typename _Operation::first_argument_type _Arg1_type;
      return binder1st<_Operation>(__fn, _Arg1_type(__x));
  }
  

 
bind1st返回的binder1st定义为：

 template <class _Operation>
  class binder1st : public unary_function<typename _Operation::second_argument_type, 
  typename _Operation::result_type>
  {
  protected:
      _Operation op;
      typename _Operation::first_argument_type value;
  public:
      binder1st(const _Operation& __x, const typename _Operation::first_argument_type& __y): 
        op(__x), value(__y) 
      {}
      typename _Operation::result_type 
      operator()(const typename _Operation::second_argument_type& __x) const
      { 
         return op(value, __x); 
      }
     typename _Operation::result_type 
     operator()(typename _Operation::second_argument_type& __x) const
     { 
        return op(value, __x); 
     }
  };

 
值得一提的是，ptr_fun以及相关的pointer_to_unary_function, pointer_to_binary_function，基本上
就是用来绑定C函数的组件，不过这里采用了很基础的模板技术，因此只实现了绑定一个参数和两个参数
的C函数。这种组件类似于loki中的functor，以及boost中的bind，只是功能弱很多。与之相关的还有
mem_fun, mem_fun_ref, mem_fun1, mem_fun1_ref等，这些都是用于绑定成员函数的。另一方面，与其说
是绑定，还不如说适配，即将函数适配为functor(特指重载operator()的类)。( Mem_fun_t is an adaptor
 for member functions )采用这些(ptr_fun, mem_fun之类的东西)组件，客端程序员可以很容易地将各种
运行体(Kevin似乎很喜欢发明各种名字)(C函数、成员函数)适配成functor，从而与STL泛型算法结合。
例如, SGI文档中给出的mem_fun例子：

struct B {
 virtual void print() = 0;
};

struct D1 : public B {
 void print() { cout << "I'm a D1" << endl; }
};

struct D2 : public B {
 void print() { cout << "I'm a D2" << endl; }
};

int main()
{
 vector<B*> V;

 V.push_back(new D1);
 V.push_back(new D2);
 V.push_back(new D2);
 V.push_back(new D1);

 for_each(V.begin(), V.end(), mem_fun(&B::print));
}

注：以上分析基于dev-cpp中自带的stl，源代码见stl_functional.h。