声明时如何给一个复数赋值操作？

Question

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

例如：

有效：

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);
               ^^^^^

否则编译器无法将 non-constant 引用绑定到作为表达式结果的临时值

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

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

你的复制构造函数声明为

    ComplexNumber(ComplexNumber &NewComplexNumber);

它通过引用来获取它的参数。引用不能绑定到临时值，例如表达式的结果（例如 a + b、a - b）。

修复：

    ComplexNumber(const ComplexNumber &NewComplexNumber);

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

Answer 3

添加一个const复制构造函数：

ComplexNumber::ComplexNumber(const ComplexNumber & NewComplexNumber)

行ComplexNumber Number = a + b;调用了class的复制构造函数。但是，a + b 的结果是 r-value，而您提供的唯一复制构造函数仅采用 l-value.

声明时如何给一个复数赋值操作？

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

c++

reference

operator-overloading

copy-constructor

complex-numbers