Is this a good idea? (Error handling with overloaded operators)

Hi.

Is this a good idea?:

<begin code>
/* Addition operator: += */
const BigFix &BigFix::operator+=(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?