已定义的运算符 C++ 不匹配

Question

我正在编写一个涉及使用复数的程序，因此我定义了一个复数类，它具有重载的运算符用于可以进行的操作。他们一直在使用其他功能和之前的测试，但对于我的一个功能，我得到以下错误代码：

||=== Build: Debug in complex (compiler: GNU GCC Compiler) ===|
/home/gagler/c_stuff/complex/polynomials.h||In function ‘Comp f(Comp*, int, Comp)’:|
/home/gagler/c_stuff/complex/polynomials.h|81|error: no match for ‘operator*’ (operand types are ‘Comp’ and ‘Comp’)|
/home/gagler/c_stuff/complex/polynomials.h|81|note: candidates are:|
/home/gagler/c_stuff/complex/complex.h|60|note: Comp Comp::operator*(double)|
/home/gagler/c_stuff/complex/complex.h|60|note:   no known conversion for argument 1 from ‘Comp’ to ‘double’|
/home/gagler/c_stuff/complex/complex.h|68|note: Comp Comp::operator*(Comp&)|
/home/gagler/c_stuff/complex/complex.h|68|note:   no known conversion for argument 1 from ‘Comp’ to ‘Comp&’|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 1 second(s)) ===|

在我的标头中显然定义了一个运算符，它接受 Comp 和 Comp 的操作数。 Comp 是我定义的类。 这是包含运算符定义的头文件：

#ifndef COMPLEX_H
#define COMPLEX_H

#define PI 3.1415926535
#include <math.h>
#include "combinatorics.h"

double abs(double num){
    return (num < 0) ? num * -1 : num;
}

class Comp{
public:
    double re;//Re(z)
    double im;//Im(z)
    Comp(double a, double b){
        re = a;
        im = b;
    }
    Comp(){
        re = 0;
        im = 0;
    }

    double arg(){
        double theta = atan(abs(im) / abs(re));
        if(re < 0){
            theta = PI - theta;
        }
        if(im < 0){
            theta *= -1;
        }
        return theta;
    }

    double mod(){
        return sqrt( re * re + im * im);
    }

    Comp conj(){
        Comp z1(re, im*-1);
        return z1;
    }

    Comp operator+(double a){
        Comp z(this->re + a,  this->im);
        return z;
    }
    void operator+=(double a){
        this->re += a;
    }
    Comp operator+(Comp &z1){
        Comp z2(this->re + z1.re, this->im + z1.im);
        return z2;
    }
    void operator+=(Comp &z){
        this->re += z.re;
        this->im += z.im;
        }
    Comp operator*(double scalar){
        Comp z(this->re * scalar, this->im * scalar);
        return z;
    }
    void operator*=(double scalar){
        this->re *= scalar;
        this->im *= scalar;
    }
    Comp operator*(Comp &z1){
        Comp z2(this->re * z1.re - this->im * z1.im, this->re * z1.im + this->im * z1.re);
        return z2;
        }
    void operator*=(Comp &z1){
        //this->re = this->re * z1.re - this->im * z1.im;
        //this->im = this->re * z1.im + this->im * z1.re;
        Comp z2(this->re * z1.re - this->im * z1.im, this->re * z1.im + this->im * z1.re);
        *this = z2;
    }
    Comp operator^(int exp){
         Comp z;
         for(int i = 0; i <= exp; i++){
            double term = ncr(exp, exp - i) * pow(this->re, exp - i) * pow(this->im, i);
            switch(i % 4){
                case(0):{
                    z.re += term;
                    break;
                }
                case(1):{
                    z.im += term;
                    break;
                }
                case(2):{
                    z.re -= term;
                    break;
                }
                case(3):{
                    z.im -= term;
                    break;
                }
            }
         }
    return z;
    }
    Comp operator/(double scalar){
        Comp z(this->re/scalar, this->im/scalar);
        return z;
    }
    void operator/=(double scalar){
        this->re = this->re/scalar;
        this->im = this->im/scalar;
    }
    Comp operator/(Comp &z1){
        Comp z2 = z1.conj();
        z2 = (z2 * (*this)) / (z2.re * z2.re + z2.im * z2.im);
        return z2;
    }
    void operator/=(Comp &z1){
        Comp z2 = z1.conj();
        *this = (z2 * (*this)) / (z2.re * z2.re + z2.im * z2.im);

    }
};

#endif //COMPLEX_H

这是代码失败的函数，它基本上只是一个计算给定复数“z”的 f(z) = ax^n+bx^(n-1)+...+k 的函数：

Comp f(Comp *poly, int deg, Comp z){
    Comp y;
    for(int i = 0; i <= deg; i++){
//here is the use of the overloaded operators
        y += (poly[i])*( z^(deg-i) );
    }
    return y;
}

我的问题是：我该如何解决这个问题，为什么会出现这个错误？谢谢！

Answer 1

这很可能是因为表达式( z^(deg-i) ) 是一个临时 Comp 对象，并且这些对象可以绑定到非常量引用。

您需要将所有运算符参数都设为const 引用。喜欢

Comp operator*(Comp const &z1){

Answer 2

问题是z^(deg-1) 返回一个Comp 类型的对象。该结果被传递给operator*，它采用Comp&，即它需要一个Comp 类型的左值； ^ 返回一个临时对象，它是一个右值。解决方法是将operator*（以及所有其他运算符）更改为const Comp&。这样就可以用左值和右值调用它们。