Question

可能重复：
Operator overloading

我想要做的是重载一个运算符，该运算符用多项式添加常量。这是类定义。

class polynomial
{
public:
    polynomial();// default constructor
    polynomial(double*,int);//  parameterized constructor
    polynomial(polynomial*);// copy constructor
    ~polynomial();//destructor
    polynomial* const operator+(polynomial*);
    polynomial* const operator+(double);
    friend polynomial* const operator+(double,polynomial);
    polynomial* operator-(polynomial*);
    polynomial* operator-(const double);
    polynomial* operator*(polynomial*);
    polynomial* polynomial::operator*(const double);
    friend ostream& operator<<(ostream&,polynomial*);
    friend double evaluate(polynomial*,double);
    friend double* extract(polynomial*);
    polynomial* operator =(polynomial*);
    int degree;
private:
    double* polyNum;
};

因为我们无法访问内置类的定义来添加我们想要的运算符作为成员函数。我们别无选择，只能使用非会员功能。但是当我试图这样做时，它会出现一个错误，“..'运算符+'必须至少有一个类型的正式参数..”

    friend polynomial* const operator+(double,polynomial*);

然而，当我尝试传递一个对象而不是它的指针时，另一个问题是，当它从其他函数返回时，它将自动调用析构函数并擦除对象内指针所指向的所有数据。

    polynomial* const operator+(double constant,polynomial p)
{
->  return p+constant;
}

p {degree = 3 polyNum = 0x00de8188 {1.0000000000000000}} polynomial

polynomial* const operator+(double constant,polynomial p)
{
    return p+constant;
->
}

p {degree = 3 polyNum = 0x00de8188 {-2.6569842580370804e + 303}} polynomial

Answer 1

你似乎对指针的需求感到困惑。（提示：你班上不需要指针。）

要回答您的具体问题，您的operator+功能应如下所示：

class polynomial {
public:
  polynomial& operator +=(double d) {
     polynum[0] += d; // or whatever
     return *this;
  }
  polynomial& operator+=(const polynomial& p) {
    for( ... ) {
      polynum[i] += p.polynum[i]; // or whatever
    }
    return *this;
  }

  // other stuff goes here, too
  ...
};

polynomial operator+(polynomial p, double d) { return p += d; }

polynomial operator+(double d, polynomial p) { return p += d; }

polynomial operator+(polynomial l, const polynomial& r) { return l += r; }

典型用法是：

int main () {
  polynomial p, q, r;
  double d;
  ... fill in p, q, and d ...
  q = p + d;
  r = d + p;
  p = q + r;
}

Answer 2

我之前唯一的复制构造函数是

polynomial(polynomial*);
// copy constructor work with pointer

当我将一个对象而不是一个指针作为参数传递给函数

时

 polynomial* const operator+(double constant,polynomial p)
{
    return p+constant;
}

局部变量只是简单地从外部变量复制值，包括p.polynum的值。结果，有两个指针指向同一个数组。当函数完成并准备返回时，它会调用析构函数来销毁局部变量p，这会破坏p.polynum数组。这就是为什么外部指针指向的数组内部的值被擦除。这就是为什么我们需要一个包含指针的类的真正复制构造函数。

解决方案：

添加额外的复制构造函数：

polynomial(polynomial*);
// copy constructor2 work with object.

如何使用内置类（左）和定义类的指针来重载操作符？

2 个答案: