#include

typedef int (*AssertHandler)(char const*, char const*, int);

int default_assert_handler(char const* expr, char const* file, int line)
{ fprintf(stderr, “Assertion (%s) failed in %s (%d)\n”, expr, file, line);
return 1;
}

AssertHandler assert_handler = default_assert_handler;

#if defined(_MSC_VER)
#define ASSERT_HALT() __debugbreak()
#else
#include
#define ASSERT_HALT() exit(__LINE__)
#endif

#ifdef DEBUG
#define assert(x) ((void)(!(x) && assert_handler(#x, __FILE__, __LINE__) && (ASSERT_HALT(), 1)))
#else
#define assert(x) ((void)sizeof(x))
#endif

#define ASSERT( n )\
if ( !n )\
{\
return;\
}

and eventually got a hint when this code wasn’t returning from the block:

ASSERT( 2 > 2 )

Thank you >.<

// This is simply not enough on some compilers.
do {} while(__LINE__ == -1)

Instead I use these macros to surround multi-line macros.
#define GorkMacroOpen do {
#define GorkMacroClose } while(__LINE__ == -1, false)

Looking forward to more articles Charles
It’s time to update

#define NDEBUG 1

#include

int main()
{
bool failed = false;
assert(failed);
}

shows ‘unused variable’ warning for both GCC and MSVC…

2. Using signals is significantly less useful than having your own macro, because your signal handler doesn’t have any callsite information that you can report to the user. __LINE__, __FILE__, and __FUNCTION__ will only tell you that you’re in your signal handler, and they won’t tell you where the assert happened. You absolutely need to write your own macro if you want to use a custom error handler AND know about the callsite.

I guess my answer to your final question “Why see all that trouble” is simply “Because there’s no easier way to do it.” You’ve presented an inferior solution, and if you’re happy with it, then by all means use it.

I use the standard assert provided in C/C++ STL. I don’t get that warning (or any other) even with ‘-Wall’ in my compiler’s paramerets. I use Dev-C++ 4.9.9.2, which is build on gcc and g++.

[quote][i]We can try the standard cast-to-void trick:
#define POW2_ASSERT(x) do { (void)(x); } while(0)[/i][/quote]

Standard C/C++ STL define’s null version of assert as follows:
#define assert(x) ((void)0)

No tricks, no hassle, so why bother writing your own when STL contains equally good (or better?) solution? Or did you forget to mention something, Charles Nicholson?

Having your own handler for errors is not an excuse: you can use the signals.h (which is also provided in C/C++ STL) to set a custom handler for SIGABRT signal, which is raised when STL’s assert() detects failure, and thus either default signal handler for that signal or your custom handler is called.

I did it with gcc and C/C++ STL, i get zero warnings wether or not NDEBUG is defined and i have my own, custom error handler (log, cleanup, shutdown).

So, my point is: Why see all that trouble?

condition ? POW2_ASSERT(something) : somethingElse();

Granted, this isn’t a terribly common or useful construct. But it is the reason why the ANSI C assert() macro is specified to be an expression of type void. You can implement this feature by replacing the if() in the definition of POW2_ASSERT() with a ?: and judicious use of parentheses and the comma operator.