Assertions in C/C++

Assertions are the statements used to check presumptions which is made by the programmers.

Example: Assertion is used to verify whether the malloc returned by the pointer is NULL or not.

For Example:

assert(i==0);
         i++;
      assert(i==1);

Syntax:

void assert (int expression);

If the above expression returns false than source code, the file number addresses to standard error and a function is called named as abort().

Code:

#include<stdio.h>
       #include<assert.h>
       int main ()
       {
             int x=7; 
             /* few large codes accidentally let us assume x in between changes to 9     
                       */
             x = 9;
// coder assumes the value of x is 7 in remaining code
assert(x==7);
 / * remaining code */
return 0;
}

Output:

Assertion fails at x==7 

Assertion versus Normal Error Handling

Assertions are mostly used to verify rational unfeasible circumstances like they used to verify the location of a code before it started running or after running finishes. It is dissimilar to normal error handling at the time of running assertions usually disables. Therefore, it will be better if we avoid writing assertion statements like this assert () which affects.

For example: If we write assert(x=9) as x changes and we know assertions disables the changes and won’t occurs in it so it will be better if we do not use assertions like this.

Ignoring Assertions

We can eliminate assertions in C/C++ at compilation time by using Pre-processor which is named as NDEBUG.

Code:

// as NDEBUG defines the program runs excellent
           #define NDEBUG
           #include<assert.h>
           int main ()
           {
int x=8; 
                 assert(x==4);
                  return 0;
             }

In Java, assertions are disabled. To enable it, we should pass a sign to run time engine.

Assertion checks are of mainly four types:

1. Precondition Assertion

2. Postcondition Assertion

3. Invariant Assertion

4.Static Assertion

1.Precondition Assertion: The precondition assertion condition satisfies before main body execution.

2.Post_Condition Assertion: The postcondition assertion satisfies after main body execution.

3.Invariant Assertion: This invariant assertion satisfies at function of each after uninteresting region.

4.Static_ Assertion: The static assert is a keyword so while using, we can exclude header and this assert verifies at compilation time instead of running time.

static _assert (condition, diagnostic message)

If the condition is false, it prints diagnostic message.

Example:

static assert (size of(long)==8, “long must be 8 bytes”);
static assert(size of(int) ==4, “int must be 4 bytes”);
       int main ()
       {
            return 0;
        }

Compilation error

\Console app\main.cpp: error: long should be 8 types

This static error should be evaluated at the time of compilation and this static_error can be placed anywhere in the code including global space.

Advantages of static error

1. At the time of compilation, libraries can detect common errors.
2. C++ std library implementation detects common error of diagnosis.

Declaration Scopes

Static assert is used in three scopes i.e.

1.Namespace scope

2.Class scope

3.Block scope

1.Namespace scope:

#include<iostream>
static assert (size of(void*) == 8,
      int main ()
      {
            cout << “Assertion passed
it does not produce any error”;
            return 0;
       }

Output:

As assertion is passed it does not produce any errors.

2.Class Scope:

#include<iostream>
using namespace std;
          template <class T, int size>
          class vector {
static assert(size>3,” vector size is too small!”);
                 T m_values[size];
};
int main ()
{
          Vector<int, 4> four;
          Vector<short,2> two;
          return 0;
}

0utput:

 Due to small vector size error occurs and static assertion fails

3.Block Scope

template <TypeName T, int N>
           void f ()
           {
static assert(N>=0, “length of array ais negative.”);
                T a[N];
            }
            int main ()
            {
f < int, -1> ();
                  return 0;
              }

Output:

As length array a is negative static assertion fails error occurs

Uses of Assertions in C program

Assertion can be defined as:

#include<assert.h>
assert(condition);

always the condition should be Boolean.

Example:

int i=0;
     assert(i>=0);

From the above code, we can see that it results true because 0>=0 so at the time of execution, the code normally continues.

If the condition results to a false, the code produces an error and the code execution stops itself.

int i=0;
//false
assert(i>0);

Example of an Assertion using Loop

#include<stdio.h>
       #include<limits.h>
       #include<assert.h>
       int loop function (int a, int b) {
    //precondition assertion (a<=b)
assert(a<=b);
              int result=0;
for (int i=a; i<=b; i++) {
                    //invariant assertion
// always result is positive but sometimes it shows negative as 
                         Result overflow
//at the case of an integer assertion fails
assert(result>=0);
                    result+=i;
 }
//postcondition assertion
//always the result is positive but in the case of 0 it fails
               assert (result>0)
               return result;
}
  int main ();
              int a=3;
              int b=10;
              printf (“loop function on %d and %d gives %d\n”, a, b, loop function
              (a, b));
              int c= INT_MAX -3;
              int d=INT_MAX;
              //the invariant assertion results false in case of c and d because it 
                 Overflows
                 printf (“loop function on %d and %d gives %d\n”, c, d, loop function
                 (c, d));
                return 0;
}

Output:

Loop function upon 3 and 10 results 52 
assert loop: loop function: assertion ‘result>=0’ failed.

The result shows negative at the higher integer values due to overflow and hence invariant assertion fails, and program execution stops, and we can handle by detecting any design flaw in it.