Thread: Assert command

>> now obviously the function foo will return a garbage value since it will overflow, will assert be able to catch this, if not what do I need to prevent the program compiling?

First of all, 'assert' is just a macro. Something along the lines of:

Code:

#define assert( condition ) do{ if( !( condition ) ) exit( 1 ); } while( 0 );

There is, of course, more to it than that, but that's the general idea. Second, it isn't really feasible to do a compile-time check - you'll have to do that at runtime (probably somewhere inside 'foo').

If we look in terms of pre-conditions, a pre-condition of foo() is that its argument must be less than the largest int value. This could be expressed in an assertion:

Code:

int foo(int i)
{
    assert(i < INT_MAX);
    return i+1;
}

But if foo() is called with user input, then when the program is compiled in some release configuration where assertions are turned off, the pre-condition could still fail if the caller does not perform such a check before calling foo(). Depending on circumstances one might throw an exception instead of using an assertion.

Nonetheless, as tabstop noted this problem (whether the int argument is the largest integer or a negative number) cannot be be generally detected at compile time since the value of i is only known at runtime.

C does not have any facilities for a compile-time assert anyway (unlike C++).
Also, when using assert, form a boolean condition. Say, you do not want the number to be negative? Then you do:

Code:

//main
assert(foo(MAXINT) >= 0) // Number must be greater or equal or 0, or it will fal

//foo function
int foo(int i)
{
   return i+1;
}

I think asserts should only be used for dangerous inputs that cannot be foreseen but is created by the program rather than directly by the user.

And of course, during debug testing.

You should try and modify your own assert really.

About this tho, I have a question:

Code:

#define assert( condition ) do{ if( !( condition ) ) exit( 1 ); } while( 0 );

I seen this a lot, but I never quite get why they need the do while loop. There must be a reason...

Actually, the best idea is to use assert with file logging.

Originally Posted by execute

I think asserts should only be used for dangerous inputs that cannot be foreseen but is created by the program rather than directly by the user.

Agreed on the part that it should not be relied on to check for user input, though I regard it as useful to check pre-conditions rather than just "dangerous inputs". Incidentally, this is C so my suggestion of exceptions does not apply.

Originally Posted by execute

I seen this a lot, but I never quite get why they need the do while loop. There must be a reason...

It is a trick to avoid problems with scope in macros (though I believe that the terminating semi-colon is usually excluded), e.g., so that an else clause that follows will not be matched with the if in the assertion.

Originally Posted by execute

II seen this a lot, but I never quite get why they need the do while loop. There must be a reason...

Preprocess and compile this and see the reason why:

Code:

#define DO_WHILE_EXPLANATION(x) x *= 2; x+=3;
#define DO_WHILE_EXPLANATION_FIXED(x) do { x *= 2; x+=3; } while(0)

int main ()
{
    int x = 0;
    while (x < 100) {
        if (x & 1)
            DO_WHILE_EXPLANATION(x);
        else
            ++x;
    }
    return x;
}

Originally Posted by Albinoswordfish

what do I need to prevent the program compiling?

You need a compile-time assert (and a compile-time-constant expression). This is sometimes defined as C_ASSERT as in MSVC. Boost also has one, which generates nicer error messages.
Usage:

Code:

C_ASSERT(MAXINT + 1 >= 0);

Originally Posted by iMalc

You need a compile-time assert (and a compile-time-constant expression).

Yes, but how does that apply to the actual question? I am not very familiar with static assertions, so would the compiler allow this?

Code:

C_ASSERT(foo(MAXINT) > MAXINT);

Of course, we are assuming that MAXINT is a macro constant, but there is nothing that says that it is not a variable besides the hint provided by the fully capitalised name.

To answer my own question about compile time assertions: BOOST_STATIC_ASSERT does not like the function call in foo(INT_MAX) even though the return value is guaranteed to be constant in this special case. It seems like even if MAXINT really is a macro constant rather than a variable that could depend on user input at runtime, trying to detect the given error at compile time is impossible even with a static assertion.

cyberfish: note the point about detecting the error at compile time.