static void myfuncchar *a)
{
assert(a); // не мееет смысла
}

...
myfunc("abcd");

my_assert( CloseHandle(hFile) ); // обрашение к OS

export my_error myfuncchar *a) // вызывается из вне
{
   my_assert(a);
   if( 0 == a )
       return invalid_parameter;

   return ok;
}

_>static void myfuncchar *a)
_>{
_>assert(a); // не мееет смысла
_>}

_>...
_>myfunc("abcd");
_>

_>my_assert( CloseHandle(hFile) ); // обрашение к OS

_>export my_error myfuncchar *a) // вызывается из вне
_>{
_>   my_assert(a);
_>   if( 0 == a )
_>       return invalid_parameter;

_>   return ok;
_>}

_>

Philosophers say that reality defies imagination by being more complex than what our mind can concoct. This is certainly true in the case of software development. There are tons of stories about assertions that were just "impossible to fire," but they actually fired. Time and again, it goes the same way. "This value is certainly positive! That pointer is obviously not null! The array? It's undoubtedly sorted; I'd bet money on that! Why recheck tautologies?" If you're a beginner, you feel like you are wasting your time when you write some assert, but much more often than you initially thought, it's going to fire to save your life. It's all because software development is complex, and anything could happen in a program that is changing. Assertions verify that what you believe is "obviously true" actually stays true.

There is an effective litmus test to differentiate the cases in which you need to use assert and when you need to use genuine error checking: you use error checking for things that could happen, even very improbably. You use assert only for things that you truly believe cannot possibly happen under any circumstances. An assertion that fails always signals a design or a programmer error — not a user error.

On the other hand, you do not want to use assertions to validate return values of functions that might fail. You don't use assert to make sure that malloc worked, that a window creation succeeded, or that a thread was started. You can, use, however, assert to make sure that APIs work as documented. For example, if some API function is documented to always return a positive value, but somehow you suspect it might have a bug, you might want to plant an assert.

void fun(unsigned int x){
switch(x){
  default: __assume(0);
  case 0: F0(); break;
  case 1: F1(); break;
}

static const F_ptr[] = { &F0, &F1 };
void fun(int x){
  F_ptr[x]();
}

static const F_ptr[] = { &F0, &F1 };
void fun(unsigned int x){
  if(x<2)
    F_ptr[x]();
}

_>static void myfuncchar *a)
_>{
_>assert(a); // не мееет смысла
_>}

_>...
_>myfunc("abcd");
_>

_>my_assert( CloseHandle(hFile) ); // обрашение к OS

_>export my_error myfuncchar *a) // вызывается из вне
_>{
_>   my_assert(a);
_>   if( 0 == a )
_>       return invalid_parameter;

_>   return ok;
_>}

_>

my_assert( CloseHandle(hFile) ); // обрашение к OS

if (param == NULL)
{
    ATLASSERT(param && "Invalid parameter, but error is not critical");
    return E_FAIL;
}

I>my_assert( CloseHandle(hFile) ); // обрашение к OS
I>

BOOL bRet = CloseHandle(hFile);
ASSERT(bRet);
UNREFERENCED_PARAMETER(bRet);