C++ 中的一元否定

Question

我几乎完成了这个程序，但是我在应用一元取反函数时遇到了问题。

我已经编写了一个基于计算复数的程序，到目前为止它运行良好，除了整个负数部分。我似乎无法弄清楚如何使我的一元否定在代码中工作，而不会警告我并因运行时错误而崩溃。

在我的 h 文件中，我有这个：

Complex operator-(const Complex &lhs);

在我的 cpp 文件中，我试图根据我上面写的内容创建这个：

Complex operator-(const Complex &lhs)
{
    return Complex(-lhs);
}

我在我的 cpp 文件上写的代码给我一个 警告 C4717 错误，上面写着："'operator-': 在所有控制路径上递归，函数会导致运行时堆栈溢出。" 当然，应用上面的数字会导致运行时错误。

我相信你们中的一些人想要完整的代码，所以这里是：header、cpp 和测试文件。 :)

感谢您的帮助。

header 文件:

#ifndef com_H
#define com_H
#include <iostream>
#include <string>

using namespace std;


/********** CLASS **********/

class Complex
{

    //The BFFs: Stream Insertion and Operators//

    friend istream &operator >> (istream &lhs, Complex &rhs);
    friend ostream &operator << (ostream &lhs, const Complex &rhs);

private:

    float real, img;

public:
            //Complex Constructor//

    Complex(float new_real = 0.0, float new_img = 0.0);

            //Complex Set-and-Get Functions//

    void setComplex(float new_real, float new_img);
    float getReal() const { return real; }
    float getImg()  const { return img; }

            //Complex Functions//

    Complex &operator+=(const Complex &rhs);
    Complex &operator-=(const Complex &rhs);
    Complex &operator*=(const Complex &rhs);
    Complex &operator/=(const Complex &rhs);

};


/********** O P E R A T O R **********/



Complex operator+(const Complex &lhs, const Complex &rhs);
Complex operator-(const Complex &lhs, const Complex &rhs);
Complex operator*(const Complex &lhs, const Complex &rhs);
Complex operator/(const Complex &lhs, const Complex &rhs);

//COMPARISON OPERATORS*/

bool operator==(const Complex &lhs, const Complex &rhs);
bool operator!=(const Complex &lhs, const Complex &rhs);
bool operator<(const Complex &lhs, const Complex &rhs);
bool operator<=(const Complex &lhs, const Complex &rhs);
bool operator>(const Complex &lhs, const Complex &rhs);
bool operator>=(const Complex &lhs, const Complex &rhs);

//NEGATION//
Complex operator-(const Complex &lhs);

#endif

cpp 文件:

#include <iostream>
#include <string>
#include <stdlib.h>
#include <math.h>
#include "com.h"

using namespace std;

//
//***************** COMPLEX CONSTRUCTORS *****************//
//
Complex::Complex(float new_real, float new_img)
{
    real = new_real;
    img = new_img;
}

void Complex::setComplex(float new_real, float new_img)
{
    real = new_real;
    img = new_img;
}


//
//***************IF REAL NUMBER IS ZERO CHECK***************//
//

void checkNum(char ops, float new_img)
{
    char i = 'i';

    if (new_img == 0)
    {
        cout << "0";
    }

    else if (new_img != 1 && ops == '-')
    {
        new_img *= -1;

        cout << new_img << i;
    }

    else if (new_img == 1 && ops == '-')
    {
        cout << "-i";
    }

    else if (new_img == 1)
    {
        cout << i;
    }

    else
    {
        cout << new_img << i;
    }

}

//
//*****************STREAM INSERTIONS*****************//
//

istream &operator >> (istream &lhs, Complex &rhs)
{
    char ops;
    char i = 'i';

    lhs >> rhs.real >> ops >> rhs.img >> i;     //lhs is another name for cin

    if (ops == '-')
    {
        rhs.img *= -1;
    }

    return lhs;
}

ostream &operator << (ostream &lhs, const Complex &rhs)
{
    char ops;
    char i = 'i';
    float new_real = rhs.real;
    float new_img = rhs.img;

    if (new_img < 0)
    {
        ops = '-';
        new_img *= -1;
    }

    else if (new_img >= 0)
    {
        ops = '+';
    }

    if (new_real == 0)
    {

        checkNum(ops, new_img);

        return  lhs << endl;

    }

    else if (new_img == 0)
    {
        return lhs << new_real;
    }

    else if (new_img == 1)
    {
        return lhs << new_real << " " << ops << " " << i;
    }

    else
    {
        return lhs << new_real << " " << ops << " " << new_img << i;
    }

    //  lhs << rhs.real << " + " << rhs.img << 'i';

}

//
//***************COMPLEX ARITHMETIC OPERATORS***************//
//***************** ( + | - | * | / |) ***************** //
//

// FORMULA for COMPLEX NUMBERS :: (a + bi)

Complex operator+(const Complex &lhs, const Complex &rhs)
{

    float a = lhs.getReal();
    float b = lhs.getImg();

    float c = rhs.getReal();
    float d = rhs.getImg();

    return Complex(a + c, b + d);

}

Complex operator-(const Complex &lhs, const Complex &rhs)
{

    float a = lhs.getReal();
    float b = lhs.getImg();

    float c = rhs.getReal();
    float d = rhs.getImg();

    return Complex(a - c, b - d);

}


Complex operator*(const Complex &lhs, const Complex &rhs)
{

    float a = lhs.getReal();
    float b = lhs.getImg();

    float c = rhs.getReal();
    float d = rhs.getImg();

    return Complex(((a * c) - (b * d)) , ((a * d) + (b * c)));


}

Complex operator/(const Complex &lhs, const Complex &rhs)
{

    float a = lhs.getReal();
    float b = lhs.getImg();

    float c = rhs.getReal();
    float d = rhs.getImg();

    //Numerator
    float myReal = (a * c) + (b * d);
    float myImg = (b * c) - (a * d);

    //Denominator
    float myDenom = (pow(c, 2) + pow(d, 2));

    return Complex(myReal / myDenom, myImg / myDenom);

}

//
//*****************COMPLEX OPERATORS EQUALS *****************//
//**************** ( += | -=  | *= | /= |) ***************** //
//

Complex &Complex::operator+=(const Complex &rhs)
{
    real += rhs.real;
    img += rhs.img;

    //*this = *this + rhs;

    return *this;
}

Complex &Complex::operator-=(const Complex &rhs)
{
    real -= rhs.real;
    img -= rhs.img;

    return *this;
}

Complex &Complex::operator*=(const Complex &rhs)
{
    real *= rhs.real;
    img *= rhs.img;

    return *this;
}

Complex &Complex::operator/=(const Complex &rhs)
{
    real /= rhs.real;
    img /= rhs.img;

    return *this;
}


//
//******************COMPLEX OPERATORS COMPARISON*****************//
//**************** ( == | != | < | <= | > | >= |)*****************//
//

bool operator==(const Complex &lhs, const Complex &rhs)
{
    if (lhs.getReal() == rhs.getReal() && lhs.getImg() == rhs.getImg())
    {
        return true;
    }

    return false;
}

bool operator!=(const Complex &lhs, const Complex &rhs)
{
    return !(lhs == rhs);
}

bool operator<(const Complex &lhs, const Complex &rhs)
{
    if (lhs.getReal() <  rhs.getReal() || lhs.getReal() == rhs.getReal() && lhs.getImg() < rhs.getImg())
    {
        return true;
    }
    return false;
}

bool operator<=(const Complex &lhs, const Complex &rhs)
{
    return ((lhs < rhs) || (lhs == rhs));
}

bool operator>(const Complex &lhs, const Complex &rhs)
{
    return !(lhs <= rhs);
}

bool operator>=(const Complex &lhs, const Complex &rhs)
{
    return !(lhs < rhs);
}

Complex operator-(const Complex &lhs)
{
    return Complex(-lhs);
}

主文件：

#include <iostream>
#include "com.h"
#include <string>

using namespace std;

int  main()
{
    Complex  userValue;

    cout << "Enter a complex value (a + bi): ";

    cin >> userValue;

    cout << "Negated: " << -userValue << endl;

    cout << "Addition:  " << userValue + Complex(0.0, 0.0) << endl;

    if (Complex(-6, 5.2f) == userValue)
        cout << "Wow! It's equal." << endl;

    return  0;

}

更新 1：哇！我刚刚再次测试它，它实际上在我输入的任何数字上崩溃，正面和负面哈哈！但是当我注释掉下面的代码时...... 来自主要

//  cout << "Negated: " << -userValue << endl;

来自 header 文件

Complex operator-(const Complex &lhs);

来自 cpp 文件

Complex operator-(const Complex &lhs)
{
    return Complex(-lhs);
}

...它仍然有效（当然没有负数。）

Answer 1

如错误所述，您正在递归调用重载函数。相反，您想使用正确的参数调用构造函数：

Complex operator-(const Complex &lhs)
{
    return Complex(-lhs.real, -lhs.imag);
}

C++ 中的一元否定

Unary Negation in C++

c++

negation