Printable View
I had an interview a while ago, one of the questions had to do with the assert command.
Lets say I had the below statement:
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?Code://main
assert(foo(MAXINT)) //is this the correct usage of assert?
//foo function
int foo(int i)
{
return i+1;
}
Assert will blow the whistle if the thing you give it is false. foo(MAXINT) is going to be ... something, most likely a large negative number; but large negative values are true, so that won't help.
And there's nothing you can do to prevent the program compiling, because there is no error. assert is runtime only.
>> 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:
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').Code:#define assert( condition ) do{ if( !( condition ) ) exit( 1 ); } while( 0 );
lets say instead of MAXINT I put in a negative number, however I want my program to not compile if this is the case how would I go about doing that?
It is not physically possible to do what you want. Often times your function and your main function won't even be compiled at the same time! There's no way to share information about what should be valid input and what not. And for that matter, what about this?
Edit: Of course, if you turn foo intoCode:printf("Enter a number: ");
scanf("%d", &bob);
foo(bob); //compiles? yes? no? who knows?
well foo(-1) will still compile but you'll get a warning out of it.Code:unsigned int foo(unsigned int)
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:
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.Code:int foo(int i)
{
assert(i < INT_MAX);
return i+1;
}
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:
I seen this a lot, but I never quite get why they need the do while loop. There must be a reason...Code:#define assert( condition ) do{ if( !( condition ) ) exit( 1 ); } while( 0 );
Actually, the best idea is to use assert with file logging.
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.Quote:
Originally Posted by execute
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.Quote:
Originally Posted by execute
Preprocess and compile this and see the reason why:Quote:
Originally Posted by execute
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;
}
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.Quote:
Originally Posted by Albinoswordfish
Usage:Code:C_ASSERT(MAXINT + 1 >= 0);
Yes, but how does that apply to the actual question? I am not very familiar with static assertions, so would the compiler allow this?Quote:
Originally Posted by iMalc
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.Code:C_ASSERT(foo(MAXINT) > MAXINT);
It won't work if int is signed, because it will wrap around to the most negative value (assuming MAXINT is the same as INT_MAX in limits.h).Quote:
Code://main
assert(foo(MAXINT)) //is this the correct usage of assert?
//foo function
int foo(int i)
{
return i+1;
}
This will work, however (the assert will be triggered) -
since it will wrap around to 0, which evaluates to false.Code://main
assert(foo(UINT_MAX)) //is this the correct usage of assert?
//foo function
unsigned int foo(unsigned int i)
{
return i+1;
}
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.
Ah sorry. Missed that point. Thanks.Quote:
cyberfish: note the point about detecting the error at compile time.