Одинарное отрицание в переполнении стека

Я почти закончил с этой программой, но у меня возникли проблемы с применением к ней функции унарного отрицания.

Я сделал программу, основанную на вычислении комплексных чисел, и до сих пор она работает отлично, за исключением всей части отрицательных чисел. Кажется, я не могу понять, как заставить мое унарное отрицание работать в коде, не предупреждая меня и не вылетая из-за ошибки во время выполнения.

В моем файле h у меня есть это:

Complex operator-(const Complex &lhs);

и в моем файле cpp я попытался создать это из того, что я написал выше:

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

Код, который я написал в моем файле cpp, дает мне Предупреждение C4717 ошибка, которая говорит: «operator-«: рекурсивен по всем путям управления, функция вызовет переполнение стека во время выполнения. « И, конечно же, применение приведенного выше числа приведет к ошибке во время выполнения.

Я уверен, что некоторые из вас хотят получить полный код, так что вот он: header, cpp и тестовый файл. 🙂

Я ценю помощь.

заголовочный файл:

#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: Ух ты! Я только что проверил это снова, и это фактически терпит крах на любом числе, которое я помещаю, положительный И отрицательный lol! Но когда я комментирую следующие коды …
от основного

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

из заголовочного файла

Complex operator-(const Complex &lhs);

из файла cpp

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

…это все еще работает (без отрицательных чисел конечно.)