Re: Did you get confused again? You seem eaily bewildered.

Scott Lurndal <scott@slp53.sl.home> wrote:

Bonita Montero <Bonita.Montero@gmail.com> writes:

Am 27.04.2025 um 16:43 schrieb Kenny McCormack:

In article <vulcf3$tsqb$1@raubtier-asyl.eternal-september.org>,
Bonita Montero  <Bonita.Montero@gmail.com> wrote:

Am 27.04.2025 um 15:33 schrieb Bonita Montero:
>

The platform with the most comfortable handling of division by zeroes
is Windows. Win32 allows to catch that errors easily, whereas with
Posix it's hard to continue the code in the same function or with
a calling function.

>
#include <Windows.h>

 
Burp!
 

#include <stdio.h>
>
using namespace std;

 
Burp again!  Are you confused about which newsgroup this is?

>
Ignore it it you target a different platform. But it would be nice
if such problems were handleable that convenient in any lanugage.

 
Why?  I've -never- needed to handle a divide by zero;  a good programmer
won't let it happen.

When you want to compute something interesting zero disisors
appear naturally.  Of course, program needs some code to
handle them in alternative way.  One pattern which appear
looks in pseudo code (not C) like:

   while(true) {
      try {
          a = random();
          r = b/a;
          return r;
      }
   }

Of course, this is oversimplified, the point is that computation
depends on pseudo-random numbers.  When given number leads to
division by zero one needs to repeat computation with different
pseudo-random number.

Of course, if platform does not trap zero disisors, then one
needs explicit test.  And one needs some way to propagate
information from point of detection to appropriate handler.
One could use code like

struct div_res {bool valid; int quo; int rem;};

struct dive_res
do_div(int a, int b) {
    struct dive_res res = {false, 0, 0};
    if (b == 0 || (b == -1 && a == INT_MIN)) {
        return res;
    } else {
        res.quo = a/b;
        res.rem = a%b;
        res.valid = true;
        return res;
    }
}

and dully propagate information about failure to the point
where it can be handled.  However, when hardware can detect
error in division it is simpler to let hardware do the work.

--
                              Waldek Hebisch