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

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 {度= 3 polyNum = 0x00de8188 {1.0000000000000000}}多项式

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

• p {度= 3 polyNum = {0x00de8188 + -2.6569842580370804e 303}}多项式

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.