Differences between assert verify trace and Its Application

The assert () macro is used to ensure that a specific condition is met. The usage is:
Assert (expression );
If the expression value is false, the entire program exits and an error message is output. If

If the value is true, continue to execute the following statement.
Before using this macro, the header file assert. h must be included.
For example
# Include <stdio. h>
# Include <assert. h>
Void main ()
{
Float a, B;
Scan ("% F", & A, & B );
Assert (B! = 0 );
Printf ("% F/N", A/B );
}
The above program needs to calculate the value of a/B, So B is required! = 0, so assert () is used in the program ()

Used to ensure B! = 0. If B = 0, the program exits.
Two versions of DEBUG are available in VC. Release. Assert () is only used in debuge and used for testing.

Whether the expressions in parentheses are true. For example, each number x cannot be 0.

Write assert (x); but this statement does not generate code to check this statement during your release.

Value, which takes effect only when debug is enabled.
Assert () is a judgment statement used to debug programs. Detailed description of assert (

Booleanexpression );
1. The booleanexpression parameter is a bool expression.
2. When the program runs the Statement, the program checks the expression booleanexpression.

Is it true or false.
When the conditions are met, the program continues to run the following code;
When the conditions are not met, the program will be stuck here for continuous running, not running down, and

The program prompts an error dialog box, indicating that the booleanexpression condition is not met.

Errors.
3. This command can be used as a protection for certain conditions to avoid importing non-conforming items.

Program crash.

The role of assert and verify Macros in debug mode is basically the same.

For row calculation, if the value is not 0, nothing is done. If the value is 0, the diagnosis information is output.

However, the effect of the two in the release mode is completely different. Assert does not calculate the expression value,

The diagnostic information is not output. Verify calculates the value of the expression, but neither the value nor the value is 0.

The diagnostic information is output.
 
Assertion is executed in a dialog box with assertion information (Program, module, and assertion rows ).

The dialog box has three buttons: "break", "repeat" ("debug"), and "continue"

("Ignore"). "break" ends the program, "continue" ignores assertions, the most useful

Is the "repeat" button. Press it to open the source code editor in the asserted place. Here you can

Test all the variable values and understand what went wrong.
Example: assert (ppointer); Assert (n> 0 & n <100); Assert (0 );
Assert is useful for simple verification, but it is useful for C ++ objects, especially cobject-derived

, There is a better method assert_valid to implement similar operations. As a general rule,

We should check the data error before starting to use each object,
The assert_valid macro makes it easy to implement the cobject derived class.
Example: assert_valid (this); assert_valid (pview );
Verify ()
Verify () and assert () are very similar. The difference is that in the release version, it still has

Effect

Evaluate the parameter expression ).
Trace ()
Trace () is basically a replica of the printf () function. The only difference is that

The result is output to the debugging window. In the release version, it is also invalid. Generally

Trace0 (), trace1 (), trace2 ()... Instead of trace ().
? These three macros do not have any material impact in the release version. Are they

The function depends on whether macro _ debug is predefined. This is for Microsoft Visual

In C ++, other compilers may have different macros.
Common usage:
To control the passed pointer:
Void somefun (sometype * ppointer)
{
Assert (ppointer );
// Some instructions.
}
You can capture strange values in the "Switch" and "if" operations.
For example:
Switch (nrgbcolors ){
Case nred: {// some instructions.} break;
Case ngreen: {// some instructions.} break;
Case nblue: {// some instructions.} break;
Default: assert (0); // We shoshould have never come here!
}
If (nwatertemp> = 0 & nwatertemp <50 ){
// Some instructions.
}
Else if (nwatertemp> = 50 & nwatertemp <= 100 ){
// Some instructions.
}
Else {
Assert (0); // We shoshould have never come here!
}
Assertion of the value:
Assert (nsomevalue> = minvalue and nsomevalue <= maxvalue );
Assert (nothervalue! = 0 );
 
Cute assert Error
Assert (m_mywnd.create ());
Vomit! This is a terrible mistake! The program works normally in the debugging version and does not work in the release version.

Remember: This is a macro that will be removed from the release. In this way, your window will always be

Will not be created. If you use MFC, do this:
Verify (m_mywnd.create ());
It runs m_mywnd.create () in the debugging version just like assert in the release version ().

In debug mode:
When the value of the test is 0, assert prompts an error and interrupts program execution. Verify will also

An error is reported, but the program execution is paused.

In release mode:
The assert statement is ignored, as if it does not exist. The verify statement itself is not executed, but its parentheses

The statement in can be executed, and the result value is available. Because verify is not executed, no error is reported.

Do not pause program execution.