Re: [boost] Infinite precision integer draft

From: Maarten Kronenburg (M.Kronenburg_at_[hidden])
Date: 2006-06-04 08:44:52

Carlo,
"Before aborting, assert() outputs the name of
its source file and the number of the line on which
it appears. This makes assert() a useful debugging
aid."
Now as users will be not interested in
my source code, I propose to let the run-time
error be an exception.
Regards, Maarten.

"Maarten Kronenburg" <M.Kronenburg_at_[hidden]> wrote in message
news:e5uf5p$53j$1_at_sea.gmane.org...
> Carlo,
> Yes the unsigned_integer decrement does
> a test in the predecrement operator,
> but it is only the test of the sign,
> which will be fast.
> Users that are VERY performance critical
> then still have the option of not using
> unsigned_integer.
> Yes the unsigned_integer is not a proper
> group; on the other hand, when a user
> runs the following program:
> unsigned int x = -2;
> cout << x << endl;
> and the user gets
> 4294967294
> then most users will be surprised,
> and not uderstand what is going on.
> The following program:
> unsigned_integer x = -2;
> cout << x << endl;
> will generate an error, which in my
> opinion is still more intuitive for most users
> who don't know what a modular integer is.
> Regards, Maarten.
>
> "Carlo Wood" <carlo_at_[hidden]> wrote in message
> news:20060604020720.GA25970_at_alinoe.com...
> > On Sat, Jun 03, 2006 at 02:54:53PM +0200, Maarten Kronenburg wrote:
> > > The assertion for unsigned_integer
> > > is an interesting possibility.
> > > In "C++ in a nutshell" I read:
> > > "If the expression evaluates to 0,
> > > assert prints a message to the standard
> > > error file and calls abort."
> > > Personally I would rather throw an
> > > exception, so that the user can determine
> > > what should happen if an unsigned_integer
> > > becomes negative.
> >
> > There is nothing to decide, it is a bug when that happens.
> > The best you can do is to dump a core (which is what assert does)
> > so that the developer can examine as close as possible to
> > the bug what has happened.
> >
> > Once the program works, an integer that should never
> > become negative will never become negative anymore,
> > and no testing for less than zero is needed.
> > You can still use a normal signed integer and just omit
> > the test (assertion).
> >
> > Thus,
> >
> >   void Foo::release(void)
> >   {
> >     assert(x > 0);
> >     if (--x == 0)
> >       do_something();
> >   }
> >
> > where x can be perfectly a signed integer, and no
> > testing overhead is done in the final application.
> >
> > rather than
> >
> >   void Foo::release(void)
> >   {
> >     if (--x == 0)
> >       do_something();
> >   }
> >
> > where x is a special type, solely to throw an exception
> > for the case that the program is bugged, needing not
> > only a total new type (with no mathematical meaning,
> > and no simularity with builtin-types*) ), but also the
> > cost of testing as part of the pre-decrement operator,
> > which can't be removed from the final application.
> >
> > *) Because, at least unsigned int is modular:
> >    both int (assuming no overflow occurs) and unsigned
> >    int are rings. While an infinite precision unsigned
> >    integer wouldn't even be a proper group.
> >
> > -- 
> > Carlo Wood <carlo_at_[hidden]>
> > _______________________________________________
> > Unsubscribe & other changes:
> http://lists.boost.org/mailman/listinfo.cgi/boost
> >
>
>
>
> _______________________________________________
> Unsubscribe & other changes:
http://lists.boost.org/mailman/listinfo.cgi/boost
>