C++ 运算符==重载

我正在为学校做一个项目，我需要创建一个bigint类，到目前为止它有4个要求

1.）编写一个方法来编写每行最多打印80位的bigint

2.）如果两个bigint相等，则编写一个比较方法。它应该返回一个布尔值

3.）编写一个方法，将bigint初始化为您提供的int值[0，maxint]

4.）编写一个方法，将bigint初始化为char[]

我想我有2和3是正确的，但我在比较两个大整数时遇到了麻烦，我希望有人能引导我正确的方向，如何将打印限制在每行80位

以下是我目前的代码：

.h文件

class bigint
{
public:

bigint(); //default constructor

bool operator==(const bigint& num1); 

bigint( int n);

bigint(char new_digits[]);


private:
    int digit[MAX];
    int digitb[MAX];

};

以下是实现文件：

#include "bigint.h"
#include<cassert>
#include<iostream>


//default constructor
bigint::bigint()
{
     for (int i = 0; i < MAX; i++) 
     {
    digit[i] = 0;
     }

     }


     bigint::bigint( int n )
     {
    int i = 0;



      while(n > 0)
    {
       digit[i] = n % 10;
       n = n /10;
       ++i;
break;
     }


  for(i; i< MAX; ++i)
      digit[i] = 0;


     }

 bool bigint::operator==(const  bigint& num1)
     {

       for(int i = 0; i < MAX; i++)
          {
        if (num1.digit == num1.digit)
              return true;
          }
        return false;

      }


   bigint::bigint(char new_digit[])
      {
     int i = 0;

         //Reads the characters of numbers until it is ended by the null symbol

            while(new_digit[i] != '\0')
             ++i;

             --i;

       //Converts the characters into int values and puts them in the digit array
         while( i >= 0)
    {
            digit[i] = new_digit[i] - '0';
            --i;
    }


}


}



int main()
  {

     #include<iostream>

using namespace std;
using PROJECT_1::bigint;

bigint a(0);

assert(a == 0);
  }

#包括“bigint.h”
#包括
#包括
//默认构造函数
bigint:：bigint（）
{
对于（int i=0；i0）
{
数字[i]=n%10；
n=n/10；
++一,；
打破
}
对于（i；i=0）
{
数字[i]=新的_数字[i]-“0”；
--一,；
}
}
}
int main（）
{
#包括
使用名称空间std；
使用PROJECT_1:：bigint；
bigint a（0）；
断言（a==0）；
}

---

顺便说一句，我并不是想为我一小时前刚开始的作业找到答案。我为此工作了一整天，最后我屈服了，请求帮助。

操作符==中的循环内容不起作用。您所做的是将

num1

的

数字

数组（技术上是指针）与

num1

的

数字

数组指针进行比较。这永远是事实。您应该将

this->digit

中的每个索引与

num1.digit

中的相应索引进行比较。大概是这样的：

bool bigint::operator==(const  bigint& num1)
{
    for(int i = 0; i < MAX; i++)
    {
        if (digit[i] != num1.digit[i])
            return false;
    }
    return true;
}

bool-bigint:：operator==（const-bigint&num1）
{
对于（int i=0；i

---

如你所见，我也将比较从相等改为不相等。这是因为，否则，如果两个

bigint

对象中只有第一个数字相同，那么使用equal将在仅检查第一个数字后返回函数

true

。

我认为您的比较实现是不正确的（我可能错了，因为您没有指定比较的条件，所以这是我的假设）因为：

在同一个传递的bigint中比较这两个数字，请参见：

bool bigint::operator==(const  bigint& num1)
{
    for(int i = 0; i < MAX; i++)
    {
        if (num1.digit == num1.digit) // it'll be always true
        return true;
    }
    return false;
}

bool-bigint:：operator==（const-bigint&num1）
{
对于（int i=0；i

既然这是家庭作业，我不会给出确切的解决方案，但对于方法，请逐位比较，看看运算符重载，应该会有所帮助。阅读、尝试并学习

对于第二个问题，您需要每行打印80位数字，因此对所有字符从头到尾运行一个循环，当循环计数器达到80（或79是从0开始）时，输出一个换行字符。这是一个解决方案

---

下次更清楚地提到需求。

您的代码中有许多问题。最直接的问题是 已经指出：

=

运算符两侧的表达式 相同，因此函数自然返回

true

在C++中编写此函数的惯用方法是：

return std::equals( 
    std::begin( digit ), std::end( digit ), std::begin( num1.digit ) );

在专业代码中，我会考虑其他糟糕的编程。 在突发任务中，它不太清楚，因为其中一个目标可能是 要学会自己写这些东西，你可能是不被允许的 在这种情况下使用标准算法。我还是会选择相同的算法 然而，基本方法是使用“迭代器”，而不是 索引：

int const* current = std::begin( digit );
int const* other   = std::begin( num1.digit );
int const* end     = std::end( digit );
while ( current != end && *current == *other ) {
    ++ current;
    ++ other;
}
return current == end;

至于代码的其余部分：

• operator=

  肯定应该是

  const

  ；否则，即使像

  myBigInt==0这样简单的东西也不会起作用
  

• 事实上，

  operator==

  应该是非成员。我喜欢 成员函数

  isEqual

  ，具有

  运算符==

  （和

  接线员！=

  ）打电话给它，但让它成为

  朋友是一个非常有效的方法
  选择也是如此
  

• 不确定digib应该做什么

• 您使用的构造函数

  int

  与使用的构造函数不兼容

  char[]

  。您需要确定内部表示是否正确 big-endian或little-endian。little-endian可能对 算术运算，但这意味着你必须处理 在

  BigInt（char[]）

  中按相反顺序排列的数字。实际上，您可以从 好像要按相反的顺序处理字符，但是 最后，您将在两个阵列上进行反向操作，而不会初始化结束 不改变顺序。（您还需要检查 使用标准的

  isdigit

  功能。）

通常，无论何时执行标准函数，都应该使用标准函数 作业（以及您的作业允许）。在

BigInt:：BigInt（char[]）

中 例如，

new\u digit+strlen（new\u digit）

将为您提供 ?

const const* source = new_digits + strlen( new_digits );
while ( source != new_digits ) {
    -- source;
    //  ...
}