Question

我是C ++的新手，并试图创建一个“BigInt”类。我决定将大部分实现基于将数字读入矢量。

到目前为止，我只为输入字符串编写了复制构造函数。

Largenum::Largenum(std::string input)
{
 for (std::string::const_iterator it = input.begin(); it!=input.end(); ++it)
    {
      number.push_back(*it- '0');
    }
}

我遇到的问题是添加功能。我已经创建了一个函数，在我测试了几次之后似乎可以工作，但是你可以看到它非常低效。我有两个不同的向量，如：

std::vector<int> x = {1,3,4,5,9,1};
std::vector<int> y = {2,4,5,6};

我想解决这个问题的方法是在较短的前加0，在这种情况下是y向量，使两个向量具有相同的大小，如：

x = {1,3,4,5,9,1};
y = {0,0,2,4,5,6};

然后使用基本样式添加添加它们。

我不想在向量Y的前面添加0，因为它会很慢而且数量很大。我目前的解决方案是反转向量，然后推回适当数量的0，然后将其反转。这可能比单纯插入前面看起来慢，我还没有测试过。

问题是在我对vector和push_back进行了所有的添加之后的结果。我留下了一个向后的向量，我需要再次使用反向！必须有一个比我的方法更好的方法，但我坚持找到它。理想情况下，我也会制作一个const。这是函数的代码：

Largenum Largenum::operator+(Largenum &A)
{
    bool carry = 0; 
    Largenum sum;                

    std::vector<int>::size_type max = std::max(A.number.size(), this->number.size());
    std::vector<int>::size_type diff = std::abs (A.number.size()-this->number.size());

    if (A.number.size()>this->number.size())
    {
        std::reverse(this->number.begin(), this->number.end());
        for (std::vector<int>::size_type i = 0; i<(max-diff); ++i) this->number.push_back(0);
        std::reverse(this->number.begin(), this->number.end());
    }
    else if (this->number.size() > A.number.size())
    {
        std::reverse(A.number.begin(), A.number.end());
        for (std::vector<int>::size_type i = 0; i<(max-diff); ++i) A.number.push_back(0);
        std::reverse(A.number.begin(), A.number.end());
    }
    for (std::vector<int>::size_type i = max; i!=0; --i)
    {
        int num = (A.number[i-1] + this->number[i-1] + carry)%10;
        sum.number.push_back(num);
        (A.number[i-1] + this->number[i-1] + carry >= 10) ? carry = 1 : carry = 0;
    }
    if (carry) sum.number.push_back(1);

   reverse(sum.number.begin(), sum.number.end());

   return sum;
}

如果有人有任何好的输入，这是我的第一个使用C ++中的类的程序，而且相当压倒性。

Answer 1

我认为你的功能与我见过的最佳功能非常接近。还有一些建议如何改进它：

十进制数字系统效率很低，大数字的位数很多。最好使用更高的基数来减少必须添加的位数。以人类可读的方式阅读和编写这样的数字会有点困难，但是你会多次优化操作，因为你的数字会更少。
当实现大整数时，我以相反的顺序表示它们，因此我在索引为0的位置具有最低有效位，在数组末尾具有最高有效位。这种方式当携带强制您添加新数字时，您只执行push_back，而不是完全相反。

Answer 2

一个问题：即使与分支错误预测相比，现代处理器上的整数模数也相当慢。而不是做一个明确的％10，尝试这个为你的第三个for循环：

int num = A.number[i-1] + this->number[i-1] + carry;
if(num >= 10)
{
    carry = 1;
    num -= 10;
}
else
{
    carry = 0;
}
sum.number.push_back(num);

C ++将大数字与运算符重载相加

2 个答案: