0

这个想法是重载 anoperator *以便它可以将表示数字的十进制值的两个字符串相乘。运算符是更大类的一部分，但这并不重要。算法和小学一样:)

这是我的代码：

Bignumber operator* (Bignumber x, Bignumber y ){
    int i, j, transfer=0, tmp, s1, s2, k;
    char add[1];
    string sol;
    string a, b;
    Bignumber v1, v2;
    a=x.GetValue();
    b=y.GetValue();

    a.insert(0,"0");
    b.insert(0,"0");

    for(i=a.length()-1; i>=0; i--){
        s1 = (int) a[i]-48;
        for(k=a.length()-i-1; k >0 ; k--){
            sol+="0";
        }
        for(j=b.length()-1; j >=0; j--){
            s2=(int) b[j]-48;
            tmp=s1*s2+transfer;
            if(tmp >= 10){
                 transfer=tmp/10;
                 tmp=tmp-(10*transfer);
             }
            itoa(tmp, add, 10);
            sol.insert(0, add);
        }
        v1=sol;
        v2=v1+v2;
        sol.erase(0);
        transfer=0;
    }
    return v2;
}

这在大多数情况下都可以正常工作，但对于某些随机值，它不能正常工作。例如对于 128*28 它返回 4854 而不是 3584。

知道可能是什么问题吗？

operators+并且=已经为该类重载Bignumber并且它们工作正常。

4

2 回答 2

3

虽然我的第一个答案解决了您的问题（无论如何，通过我的测试），但这里有一个替代实现；我没有你的Bignumber课，所以我写了一个小假的来测试：

#include <string>
#include <ios>
#include <iostream>
#include <ostream>
#include <sstream>

class Bignumber
{
    static inline unsigned long long strtoull(std::string const& str)
    {
        unsigned long long val;
        return std::istringstream(str) >> val ? val : 0uLL;
    }

    unsigned long long val_;

public:
    Bignumber() : val_() { }
    explicit Bignumber(unsigned long long const val) : val_(val) { }
    explicit Bignumber(std::string const& str) : val_(strtoull(str)) { }

    Bignumber& operator +=(Bignumber const rhs)
    {
        val_ += rhs.val_;
        return *this;
    }

    std::string GetValue() const
    {
        std::ostringstream oss;
        oss << val_;
        return oss.str();
    }
};

Bignumber operator *(Bignumber const x, Bignumber const y)
{
    typedef std::string::const_reverse_iterator cr_iter_t;

    std::string const& a = '0' + x.GetValue();
    std::string const& b = '0' + y.GetValue();

    Bignumber ret;
    for (cr_iter_t a_iter = a.rbegin(), a_iter_end = a.rend(); a_iter != a_iter_end; ++a_iter)
    {
        unsigned transfer = 0u;
        std::string sol(a.end() - a_iter.base(), '0');
        for (cr_iter_t b_iter = b.rbegin(), b_iter_end = b.rend(); b_iter != b_iter_end; ++b_iter)
        {
            unsigned tmp = static_cast<unsigned>(*a_iter - '0') * static_cast<unsigned>(*b_iter - '0') + transfer;
            if (tmp >= 10u)
            {
                transfer = tmp / 10u;
                tmp -= transfer * 10u;
            }
            sol.insert(sol.begin(), static_cast<char>(tmp + '0'));
        }
        ret += Bignumber(sol);
    }
    return ret;
}

int main()
{
    Bignumber const z = Bignumber(123456789uLL) * Bignumber(987654321uLL);
    std::cout << std::boolalpha << (z.GetValue() == "121932631112635269") << std::endl;
}
于 2011-04-03T18:17:05.983 回答
1

itoanull 终止它写入的字符串，因此add对于写入它的数据来说太小了，从而导致内存损坏。更改addto的定义，char add[2];它应该可以工作。

于 2011-04-03T17:16:12.970 回答