   look at the statement
  #define assert(exp) (void)( (exp) || (_assert(#exp, __FILE__, __LINE__), 0) )the void just cast stuff in ( ) to void type??what do symbol , do in exp || ( return value, 0 ) ??   
  Here, the "comma operator" is used. It means "evaluate the first thing, throw away the result, then evaluate the second thing and yield that value". This is done when it's the side effects of the first thing that are important and the value is not cared about.The void is a cast to void type, which is a way of throwing a value away completely - but that isn't really necessary; it's just a safeguard so that you don't for example write "assert(3*4) * 5".What happens is:assert(x*y) gets expanded to something like (void)( (x*y) || (_assert("x*y", "foo.cpp", 123), 0) ). The __FILE__ token is replaced with the name of the current source file, as a string, and the __LINE__ token is replaced with the line number in the file where the macro is used.At runtime, the left side of the || is evaluated. If it's true (non-zero), then the || operator short-circuits, and the result of the whole thing is that non-zero value. It then gets thrown away by the void cast.If the left side is false (zero), then the _assert() function is invoked, which, depending on whether we're in the release mode, may make a call to terminate the program, print a diagnostic message using the provided text, name and line number, etc. It returns some value that we don't care about, so we replace it with 0 via the comma operator, and then throw that away again with the void cast (this is completely redundant AFAICT).   ;  The statement is equivalent to:a || b;  which does nothing but compute the value and throw it away. Some compilers will generate a warning because they suspect that code like that may be a mistake. Casting the expression to void:(void)( a || b ); simply makes the warning go away.   ;  Arn't macros great!   