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);

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.