在声明过程中如何将操作分配给复数？

Question

我正在编写一个用于复数的类，当我声明其中的一个时，必须在可以分配给它的操作之前和之后声明它。

---

例如：

这有效：

ComplexNumber Number;  
Number = AnotherComplex + (or -) AgainAnotherComplex;  

---

这不起作用：

ComplexNumber Number = AnotherComplex + (or -) AgainAnotherComplex;

---

我离开的是.h文件：

#ifndef COMPLEX_NUMBERS_H_INCLUDED
#define COMPLEX_NUMBERS_H_INCLUDED

#include <iostream> // for std namespace

class ComplexNumber
{
    public:
        ComplexNumber();
        ComplexNumber(float RealPart, float ImaginaryPart);
        ComplexNumber(ComplexNumber &NewComplexNumber);
        ~ComplexNumber();
        void SetRealPart(float RealPart);
        void SetImaginaryPart(float ImaginaryPart);
        friend ComplexNumber operator+(const ComplexNumber Complex1, const ComplexNumber Complex2);
        friend ComplexNumber operator-(const ComplexNumber Complex1, const ComplexNumber Complex2);
        friend std::ostream & operator<<(std::ostream &output, const ComplexNumber &NumberToDsiplay);
        friend std::istream & operator >>(std::istream &input, ComplexNumber &NumberToInput);
        bool operator==(const ComplexNumber Complex);
        bool operator!=(const ComplexNumber Complex);

    private:
        float RealPart;
        float ImaginaryPart;
};

#endif // COMPLEX_NUMBERS_H_INCLUDED

我也将.cpp文件留在这里：

#include "Complex Numbers.h"

ComplexNumber::ComplexNumber()
{
    RealPart = 0;
    ImaginaryPart = 0;
}

ComplexNumber::ComplexNumber(float RealPart, float ImaginaryPart)
{
    SetRealPart(RealPart);
    SetImaginaryPart(ImaginaryPart);
}

ComplexNumber::~ComplexNumber()
{
}

ComplexNumber::ComplexNumber(ComplexNumber &NewComplexNumber)
{
    RealPart = NewComplexNumber.RealPart;
    ImaginaryPart = NewComplexNumber.ImaginaryPart;
}

void ComplexNumber::SetRealPart(float RealPart)
{
    this->RealPart=RealPart;
}

void ComplexNumber::SetImaginaryPart(float ImaginaryPart)
{
    this->ImaginaryPart=ImaginaryPart;
}

ComplexNumber operator+(const ComplexNumber Complex1, const ComplexNumber Complex2)
{
    ComplexNumber TemporaryComplexNumber;
    TemporaryComplexNumber.RealPart = Complex1.RealPart + Complex2.RealPart;
    TemporaryComplexNumber.ImaginaryPart = Complex1.ImaginaryPart + Complex2.ImaginaryPart;

    return TemporaryComplexNumber;
}

ComplexNumber operator-(const ComplexNumber Complex1, const ComplexNumber Complex2)
{
    ComplexNumber TemporaryComplexNumber;
    TemporaryComplexNumber.RealPart = Complex1.RealPart - Complex2.RealPart;
    TemporaryComplexNumber.ImaginaryPart = Complex1.ImaginaryPart - Complex2.ImaginaryPart;

    return TemporaryComplexNumber;
}


std::ostream & operator<<(std::ostream &output, const ComplexNumber &NumberToDsiplay)
{
    if(NumberToDsiplay.ImaginaryPart > 0)
        output << std::endl << NumberToDsiplay.RealPart << "+" << NumberToDsiplay.ImaginaryPart << "i";
    else if(NumberToDsiplay.ImaginaryPart < 0)
        output << std::endl << NumberToDsiplay.RealPart << "" << NumberToDsiplay.ImaginaryPart << "i";
    else if(NumberToDsiplay.ImaginaryPart == 0)
        output << std::endl << NumberToDsiplay.RealPart << "  (The imaginary part is equal to 0)";
    return output;
}

std::istream & operator >>(std::istream &input, ComplexNumber &NumberToInput)
{
    std::cout << "Enter the real part: ";
    input >> NumberToInput.RealPart;
    std::cout << "Enter the imaginary part: ";
    input >> NumberToInput.ImaginaryPart;
}

bool ComplexNumber::operator==(const ComplexNumber Complex)
{
    return RealPart==Complex.RealPart && ImaginaryPart==Complex.ImaginaryPart;
}

bool ComplexNumber::operator!=(const ComplexNumber Complex)
{
    if(RealPart != Complex.RealPart && ImaginaryPart != Complex.ImaginaryPart)
            return true;
    else if(RealPart != Complex.RealPart && (!(ImaginaryPart != Complex.ImaginaryPart)))
            return true;
    else if(ImaginaryPart != Complex.ImaginaryPart && (!(RealPart != Complex.RealPart)))
        return true;

    return false;
}

Answer 1

只需像这样声明复制构造函数

ComplexNumber( const ComplexNumber &NewComplexNumber);
               ^^^^^

否则，编译器无法将非常量引用绑定到表达式所产生的临时值

AnotherComplex + (or -) AgainAnotherComplex

调用任何一个运算符

    friend ComplexNumber operator+(const ComplexNumber Complex1, const ComplexNumber Complex2);
    friend ComplexNumber operator-(const ComplexNumber Complex1, const ComplexNumber Complex2);

依次应声明为

    friend ComplexNumber operator+(const ComplexNumber &Complex1, const ComplexNumber &Complex2);
    friend ComplexNumber operator-(const ComplexNumber &Complex1, const ComplexNumber &Complex2);

那就是参数应该是引用类型。

而这个运算符的定义

bool ComplexNumber::operator!=(const ComplexNumber Complex)
{
    if(RealPart != Complex.RealPart && ImaginaryPart != Complex.ImaginaryPart)
            return true;
    else if(RealPart != Complex.RealPart && (!(ImaginaryPart != Complex.ImaginaryPart)))
            return true;
    else if(ImaginaryPart != Complex.ImaginaryPart && (!(RealPart != Complex.RealPart)))
        return true;

    return false;
}

没什么意义。

像这样定义

bool ComplexNumber::operator!=(const ComplexNumber &Complex) const
{
    return not( *this == Complex );
}

注意const参数列表后面的限定符。您需要将相同的限定词添加到中operator ==。

Answer 2

该=报关单是没有分配。

ComplexNumber a = b + c;

只是另一种写作方式

ComplexNumber a(b + c);

也就是说，它初始化a从b + c通过调用拷贝构造函数。

您的副本构造函数声明为

    ComplexNumber(ComplexNumber &NewComplexNumber);

它以参考为依据。引用不能结合临时值如表达式（例如的结果a + b，a - b）。

固定：

    ComplexNumber(const ComplexNumber &NewComplexNumber);

根据经验，复制构造函数应始终通过const引用接受其参数。