bigInt 加减法事项

Question

我目前正在做一项学校作业（很抱歉，我的问题是关于我的作业，但我不是在问代码中使用的算法）。我现在正在做算术部分，加法和减法。由于只有两个运算符，因此有 8 种运算组合。在我的程序中，我可以做到这四种情况：

（+a）+（+b） （-a）+（-b） （-a）-（+b） （+a）-（-b）

但是，我无法弄清楚其他四种情况的方法， 即

（+a）+（-b） （-a）+（+b） （-a）-（-b） （+a）-（+b）

真心希望各位大神能对这四种情况的处理提出建议和意见。

这是我的代码：

linkedListType.h： 是一个普通的链表头文件，这里就不贴出全部代码了。

大整数.h： 这里面的函数很长。因此，我跳过了将它们发布出去。

#ifndef BIG_INTEGER_H
#define BIG_INTEGER_H

#include <stack>  
#include <iostream>
#include "linkedListType.h"

using namespace std;

class bigInteger
{
private:
    int sign;                       // set 0 for positive, 1 for negative
    linkedListType<int> digits;     // internal linked-list for storing digits in reverse order

public:
    bigInteger();                           // default constructor
    bigInteger(const bigInteger& other);    // copy constructor

    // Overload constructor
    // Use an numerical string to construct this bigInteger
    // For negative number, the first char in the string is '-'
    // e.g. "-12345"
    bigInteger(const string& number);       

    // overload the assignment operator
    const bigInteger& operator= (const bigInteger& other);

    // Return a new bigInteger that is equal to *this + other
    // The contents of this and other should not be modified
    bigInteger& operator+ (bigInteger& other);

    // Return a new bigInteger that is equal to *this - other
    // The contents of this and other should not be modified
    bigInteger& operator- (bigInteger& other);

    // Print a big integer
    // Since the digits are stored in reverse order in the internal
    // list, you should print in reverse order
    // Print "undefined" if the digits list is empty
    friend ostream& operator<<(ostream& os, bigInteger& n);
};

Answer 1

所有的 cmets 都在处理运算符重载的东西，但我怀疑 OP 是关于如何计算操作数符号的所有组合以进行加法和减法。

1. 二的补码

   大多数 HW 整数 ALU 实现使用二进制补码表示有符号数。这意味着：

   -X = (X^0xFFFFFFFF)+1; // 32 bit example
   

   仅通过反转所有位并增加结果而获得的负值。因此，当符号位仍为 MSB 时，您可以对所有加法/减法和符号组合使用单加法器架构。这种编码处理有符号和无符号操作的方式相同，因此对于加法，您完全没有问题（只需添加即可），而对于减法，只需反转第二个操作数的符号并添加。

   C++ 实现如下所示：

   bool bigInteger::sign() { return MSB_of_this; }
   bigInteger bigInteger::operator+ () { bigInteger z=*this; return z; }
   bigInteger bigInteger::operator- () { bigInteger z=*this; /* here negate all bits and increment z*/ return z' |z; }
   bigInteger bigInteger::operator+ (bigInteger& y)
    {
    bigInteger z;
    // here do z = *this + y as if all operands were positive
    return z;
    }
   
   bigInteger bigInteger::operator- (bigInteger& y0)
    {
    bigInteger z;
    y=-y0; // invert sign in temp variable to avoid changing input operand value !!!
    // here do z = *this + y as if all operands were positive
    return z;
    }
   

   请注意，我没有更改任何输入操作数，并且所有返回都是单独的变量（即使对于一元+也不使用它）。这是由于操作数的链式能力。如果不以这种方式编码，一些编译器很难在一行中菊花链超过 3 个运算符，这意味着您无法编译像

   这样的行

   c=a+b-c*a*b/(s-d)+(23*q);
   

   相反，您必须将其分解为更简单的术语...

2. 如果你不使用补码

   然后你必须处理输入操作数的符号。最常见的情况是您将符号标志作为单独的变量，而不是在数字位内。在这种情况下，您需要一些根本不考虑登录的功能

   bigInteger uadd(bigInteger &a,bigInteger &b); //=|a|+|b|
   bigInteger usub(bigInteger &a,bigInteger &b); //=|a|-|b| but operands must be: |a|>|b|
   bool        ugeq(bigInteger &a,bigInteger &b); //=|a|>=|b| Unsigned Greater or EQual
   

   这很容易

   加法

   • 只有相同符号的数字才能相加，否则将其转换为减法

   减法

   • 只有当数字是相同的符号并且第一个操作数大于或等于第二个操作数时，您才能对数字进行子分类。

   所以应该是这样的：

   bigInteger bigInteger::operator+ (bigInteger& y)
    {
    bigInteger z;
    bool sx,sy;
    sx=sign();
    sy=y.sign();
    if (sx==sy) z=uadd(*this,y);  // same signs is add
    else                            // not then first operand for (a-b) is the positive one
     {
     if (sx) return y-(*this);
     else    return (*this)-y;
     }
    // here set the sign to the same as operands
    z.set_sign(sx);
    return z;
    }
   

   因为这是一个分配，我将留下 - 运算符没有代码。

   这将与+ 运算符非常相似，但您需要按绝对大小对输入操作数进行排序（使用ugeq）并将结果sign 设置为abs 较大的值。如果您交换了操作数，则反转结果的符号。仅当展位操作数是相同符号时才减去，否则转换为 (a+b) ...

希望对你有帮助