如何在声明期间将操作分配给复数

How to assign an operation to a complex number during the declaration?

本文关键字:分配 操作 声明      更新时间:2023-10-16

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


例如:

这有效

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;
}

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

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 ==的相同限定符。

声明

中的=不是赋值。

ComplexNumber a = b + c;

只是另一种写作方式

ComplexNumber a(b + c);

即,它通过调用复制构造函数从b + c初始化a

复制构造函数声明为

    ComplexNumber(ComplexNumber &NewComplexNumber);

它通过引用来接受其论点。引用不能绑定到临时值,例如表达式的结果(例如 a + ba - b(。

修复:

    ComplexNumber(const ComplexNumber &NewComplexNumber);

根据经验,复制构造函数应始终通过 const 引用获取其参数。

添加一个常量复制构造函数:

ComplexNumber::ComplexNumber(const ComplexNumber & NewComplexNumber)

该行ComplexNumber Number = a + b;调用类的复制构造函数。但是,a + b的结果是 r 值,您提供的唯一复制构造函数仅采用 l 值。