INFO: Overflow in Integer Math Expressions Not Checked

• The Microsoft Compiler (CL.EXE) included with

      - Microsoft C for MS-DOS, versions 6.0, 6.0a, 6.0ax
      - Microsoft C for OS/2, versions 6.0, 6.0a
      - Microsoft C/C++ for MS-DOS, version 7.0
      - Microsoft Visual C++ for Windows, versions 1.0 1.5
      - Microsoft Visual C++ 32-bit Edition, versions 1.0, 2.0, 2.1, 4.0, 5.0
  

SUMMARY

The operations performed by the integer arithmetic and shift operators do not check for overflow or underflow conditions. Information may be lost if the result of an operation cannot be represented in the type of the operands after conversion. All expressions are evaluated prior to assignment to a variable.

The compiler will generate the following warning in some cases:

   warning C4307: 'operator' : integral constant overflow

Rules for numeric conversion are described in the "Microsoft C Language Reference" manual.

MORE INFORMATION

The following 3 examples demonstrates the overflow condition for 16-bit compilers:

   /* compile options needed: none */

   #include <stdio.h>
   void main(void);
   void main()
   {
       long l;
       int i = 70;
       int j = 1000;

       l = 70 * 1000;              /* First Example            */
                                   /* C4307 in version 7 and later */
       printf( "l = %ld\n", l );   /* l = 4464 = 70000 % 65536 */
                                   /* Overflow not caught!!!   */

       l = i * j;                  /* Second Example            */
       printf( "l = %ld\n", l );   /* l = 4464 = 70000 % 65536 */
                                   /* Overflow not caught!!!   */

       l = 70L * 1000;             /* Third Example           */
       printf( "l = %ld\n", l );   /* l = 70000                */
                                   /* arithmetic in long--no   */
                                   /*   overflow               */
   }

The third example is a work around. Conversions occur if the types of the operands are different. Note: 70 is a long integer (32 bits; without the L, it is considered a normal integer of 16 bits). Because a long integer is used, all operands are converted to long and the math is done using 32-bit arithmetic. The product is large enough to handle the multiplication, so the correct result of 70,000 is generated.