Hi.

Is this a good idea?:

<begin code>

/* Addition operator: += */

const BigFix &BigFix:

perator+=(const BigFix &rhs)

{

ErrorType err;

int lhs_sign = sign, rhs_sign = rhs.sign;

/* Special cases */

if(lhs_sign == 0) /* interpreted as zero */

{

/* treat as zero */

return(rhs);

}

if(rhs_sign == 0) /* interpreted as zero */

{

/* treat as zero */

return(*this);

}

/* Compare signs */

if(lhs_sign == rhs_sign)

{

/* Just do ordinary addition */

if((err = MPFix_AddUnsigned(this, &rhs)).dwErrCode !=

XXXX_SUCCESS)

throw Exception(err); <<<<<<<<<<<<<<<<<< here

/* Set sign */

sign = lhs_sign;

}

if((lhs_sign == 1) && (rhs_sign == -1))

{

/* Subtract */

if((err = MPFix_SubUnsigned(this, &rhs)).dwErrCode !=

XXXX_SUCCESS)

throw Exception(err); <<<<<<<<<<<<<<<<<< here

}

if((lhs_sign == -1) && (rhs_sign == 1))

{

/* Subtract */

sign = 1;

if((err = MPFix_SubUnsigned(this, &rhs)).dwErrCode !=

XXXX_SUCCESS)

throw Exception(err); <<<<<<<<<<<<<<<<<< here

/* Reverse sign (we subtracted |this| - |rhs|, we want |rhs| - |

this|) */

sign = -sign;

}

/* Done! */

return(*this);

}

<end code>

What does that do, you might ask? Well, it's for a bignum library I've

been making for a program that needs it, and it's supposed to overload

the "+=" operator to add the big numbers, in this case big fixed-point

numbers. I left out a few things like the definition of ErrorType and

MPFix_AddUnsigned(), MPFix_SubUnsigned() for brevity but they are not

what I am asking about here. You should be able to get the gist of

what the code is supposed to do, just remember that

MPFix_AddUnsigned() and MPFix_SubUnsigned() are just add/sub routines

that treat both operands as positive.

Anyway, with the explanation out of the way, I'd like some criticism

of this, especially of the whole error handling. Is it really a good

idea to just throw exceptions like that out of the operator on an

overflow? Or would it be better to instead have some sort of "error

flag" in the BigFix that is usually zero, but then is set to some

nonzero number when an error occurs, depending on the error? The

problem is that we have to catch exceptions from _every_ piece of

code that uses the numbers. Unfortunately (or fortunately?) these seem

to be the only two ways of getting error information outside of an

overloaded operator like that (since it's meant to be used in

expressions like "a += b" then it must return a _BigFix_ and not

something else). So is this a good idea or a bad one?