Thread: handling overflow, underflow etc

Hi, I have written a small function that can (I think) deal with
overflow/underflow while adding integers and divide by zero problem.
Can some one please tell me if I have done it correctly ? Would it be
safe to extend it to double precision floating point numbers since we
know that there is always some margin for error while adding floating
point numbers ? What other functions should I look to implement for my
project which needs heavy numerical computation ?

Code:

#include <stdio.h>
#include <limits.h>

int add_chk(int a, int b)
{
    if (b > 0)
    {
        if (a > INT_MAX - b)
        {
            fprintf(stderr, "Overflow error\n");
            return (INT_MAX);
        }
    }

    if (b < 0)
    {
        if (a < INT_MIN - b)
        {
            fprintf(stderr, "Underflow error\n");
            return (INT_MIN);
        }
    }

    return (a + b);

}

int div_chk(int a, int b)
{
    if (b == 0)
    {
        fprintf(stderr, "Division by zero attempted\n");
        return (INT_MAX);
    }

    return (a/b);

}

int main(void)
{
    int i;
    int x, y;

    clrscr();
    printf("Enter two numbers\n");
    if (scanf("%d %d", &x, &y) != 2)
    {
      fprintf(stderr, "Error in user input\n");
      return (1);
    }

    if  ((x < INT_MAX && x > INT_MIN) && ( y < INT_MAX && y > INT_MIN))
    {
        i = add_chk(x, y);
        printf("Sum: %d\n", i);
        i = div_chk(x, y);
        printf("Div: %d\n", i);
    }
    else
    {
      fprintf(stderr, "Values entered are out of range\n");
      return (1);
    }
    return (0); 
}

if a larger type is available (eg 64-bit in your case, via "long long int" or "__int64") you can always cast it to the bigger type first and do the addition there and check the result.

Originally Posted by broli86

Code:

    clrscr();

You do know that clrscr() isn't a standard C/C++ function right?

What about mult_chk() and subt_chk()?

Originally Posted by cpjust

You do know that clrscr() isn't a standard C/C++ function right?

What about mult_chk() and subt_chk()?

I don't think subt_chk is needed because add_chk can take care of it. I have to implement mul_chk and make div_chk more elaborate as to how it should deal with :

INT_MIN/ -1 , 0/0 inf/0 etc etc

Originally Posted by zacs7

0/0 is Not a number (or it is, rather confusing )

Ie, how many times do you have to subtract 0 from 0 to get to 0? 1 is correct, as is 2 as is 3, even 58974

Perhaps take after the IEEE floating point standard "n / 0 is positive infinity when n is positive, negative infinity when n is negative, and NaN when n = 0". Maybe:

Code:

enum divideError_e
{
    DE_NONE = 0,
    DE_NAN,
    DE_DIVIDE_BY_ZERO
    /* ... etc */
};

enum divideError_e divide_check(int a, int b)
{
    if(a == 0 && b == 0)
        return DE_NAN;

    if(b == 0)
        return DE_DIVIDE_BY_ZERO;

    /* etc */

    return DE_NONE;
}

/* ... */

int a = 10, b = 20, result = 0;

if(divide_check(a, b) == DE_NONE)
    result = a / b;

Thanks for that idea. I also have to take care of division overflow i.e. a/b > DBL_MAX. I'm not sure if loss of precission will be an issue since I'm using double data type.