Program Defensively

There's nothing worse than running an optimized build, where the symbols are gone and the locals wrong, because an edge condition happened. And yes, we can play tough and decide that such cases are so rare, we don't put a check for it.

And by Murphy's law, nothing happens the first six months; then you get a crash a couple of days before submitting to your publisher, and it will take the best guys in your team to track it. And very probably, a very simple edge condition will have caused this.

For example:
int * FunctionThatNeverFails( int nSlots, int * pOriginal )
{
int * pNewData = new int[ nSlots ];
memcpy( pNewData, pOriginal, nSlots * sizeof( int ) );
return pNewData;
}

A lot of things can go wrong here. So let's look at the defensive function:

int * FunctionThatNeverFails( int nSlots, int * pOriginal )
{
ASSERT( nSlots > 0 );
ASSERT( pOriginal != NULL );
int * pNewData = new int[ nSlots ];
ASSERT( pNewData != NULL );
memcpy( pNewData, pOriginal, nSlots * sizeof( int ) );
return pNewData;
}

Too much typing? Overkill?
Yes, but it will trap a bunch of things we are sometimes lazy (or just too confident) won't happen at all.