0

我对类非常陌生，虽然我编写了所有其他代码，但在我的两个成员函数的末尾我仍然缺乏一些实现。

这是我的标题：

class bignum
{
public:
// Constructors.
bignum();
bignum(int num_digits);
bignum(const string &digits);
bignum(const bignum &other);

// Destructors.
~bignum();

// Assignment operator.
bignum &operator=(const bignum &other);

// Accessors
int digits() const;
int as_int() const;
string as_string() const;
void print(ostream &out) const;
bignum add(const bignum &other) const;
bignum multiply(const bignum &other) const;
bool equals(const bignum &other) const;
int PublicNumberTest;

private:
// Pointer to a dynamically-allocated array of integers.  

int *digit;

// Number of digits in the array, not counting leading zeros.

int ndigits;
}; 
#endif

这是我的成员函数之一：

bignum bignum::multiply(const bignum& other) const{
bignum product;
bignum row;
int carry = 0;
int sum = 0;
int j = 0;
int *temp_row = new int[];
for (int i = 0; i < ndigits-1; i++){
    carry = 0;
    temp_row[i] = 0;
    for (j; j < other.digits - 1; j++){
        sum = digit[i] * other.digit[j] + carry;
        temp_row[i + j] = sum % 10;
        carry = sum / 10;
    }
    if (carry>0)
        temp_row[i + j] = carry;
    row = row operator+temp_row //This is what I don't understand. How can I 
        product = product.add(row);  //assign the contents of temp_row?

}
}

还有一个，但基本上是同样的问题。我有一个数组，我想将其复制到我的...类的内容并放置在其中？我猜？谢谢阅读。

4

3 回答 3

0

2 种方法：“旧”方法，应该与调用析构函数然后调用复制构造函数非常相似：

bignum& bignum::operator=(const bignum& other)
{
    delete[] digit;
    ndigits = other.ndigits;
    digit = new int[ndigits];
    for (int i = 0; i != ndigits; ++i) {
         digit[i] = other.digit[i];
    }
    return *this;
}

代码也可以写成：

bignum& bignum::operator=(const bignum& other)
{
    this->~bignum();
    new(this) bignum(other);
    return *this;
}

现在不鼓励这种旧方法，因为它不是异常安全的。

异常安全的“新”方式：定义一个从不抛出任何异常的 swap() 成员方法，并使用它来实现 operator=()：

void bignum::swap(bignum& other) noexcept
{
    std::swap(ndigits, other.ndigits);
    std::swap(digit, other.digit);
}

bignum& bignum::operator=(const bignum& other)
{
    bignum tmp(other);
    this->swap(tmp);
    return *this;
}
于 2013-10-19T02:29:16.340 回答
0

如果您想temp_row[]用作this对象的数字集，您可以这样做：

delete [] digits;
digits = new_row;

您可能也应该更新ndigits。

于 2013-10-19T01:08:53.483 回答
0

而不是计算出你的多位数乘法，我只是留下一些东西来解决，

您要执行 c = a b 还是 a = a b？也就是说，您是打算将两个参数相乘，产生一个临时参数，然后将其分配给第三个参数，还是只打算将对象 a 乘以参数 b？

我的意图是 C = A*B

然后你需要分配（新的）一个目标bignum，

使用朋友运算符重载应该可以解决您的需求；定义二元运算符是常见的习惯用法（请注意，我没有解决您分配正确位数的问题），

friend bignum operator+(const bignum& a, const bignum& b); //in class

//you want to calculate A * B --> C
//you need a temporary place to calculate C, then produce a new C,
bignum bignum::multiply( const bignum& A, const bignum& B ) const
{
    //Your A is this, A.digit[];
    //Your B is other, B.digit[];
    //Yout C is temp, a buffer for calculations,
    bignum temp;

    int carry = 0;
    int sum = 0;
    int j = 0;
    //you don't need this, you have temp.digit[];
    for (int i = 0; i < this->ndigits-1; i++)
    {
        carry = 0;
        temp.digit[i] = 0;
        //what do you want to initialize j to?
        for (j; j < B.ndigits - 1; j++)
        {
            sum = A.digit[i] * B.digit[j] + carry;
            temp.digit[i + j] = sum % 10;
            carry = sum / 10;
        }
        if (carry>0)
            temp.digit[i + j] = carry;
    }
    return bignum(temp); //allocate a new bignum
}

有关如何重载二元运算符的示例，请参见此处...

这样做有缺点（返回一个常量，不能将两个以上的加法链接在一起），但基本上你做了类似的事情，但是使用(this->)指针，

//you want to calculate A * B --> C
//you need a temporary place to calculate C, then produce a new C,
bignum bignum::multiply(const bignum& other) const
{
    //Your A is this, this->digit[];
    //Your B is other
    //Yout C is temp product, a buffer for calculations,
    bignum temp;

    int carry = 0;
    int sum = 0;
    int j = 0;
    for (int i = 0; i < this->ndigits-1; i++)
    {
        carry = 0;
        temp.digit[i] = 0;
        for (j; j < other.ndigits - 1; j++)
        {
            sum = this->digit[i] * other.digit[j] + carry;
            temp.digit[i + j] = sum % 10;
            carry = sum / 10;
        }
        if (carry>0)
            temp.digit[i + j] = carry;
    }
    //bignum product;
    //return *this = temp; //do this,
    return bignum(temp); //or you should probably return a new object
}

您可能应该返回一个新对象。

于 2013-10-19T02:59:31.873 回答