问题与重载分配运算符

所以我遇到的问题是在我的c + +程序，当我尝试和测试我重载的分配运算符。问题与重载分配运算符

声明：

cm6 = cm5;

应该设置CM6等于CM5，但CM6的价值不会改变。这里是我的代码：

Proj_11.h

#include <iostream> 
#include <string> 
#include <iomanip> 

using namespace std; 

class ComplexNumber 
{ 
    private: 
     double _real; 
     double _imaginary; 
    public: 
     ComplexNumber(); 
     ComplexNumber(double, double); 
     ComplexNumber(ComplexNumber&); 
     ComplexNumber operator+ (ComplexNumber); 
     ComplexNumber operator- (ComplexNumber); 
     ComplexNumber operator* (ComplexNumber); 
     ComplexNumber operator/ (ComplexNumber); 
     ComplexNumber operator= (ComplexNumber); 
     bool operator== (ComplexNumber); 
     friend ostream& operator<< (ostream&, ComplexNumber); 
}; 

void Menu();

Proj_11.cpp

#include "Proj_11.h" 

//Global Constants 
const double NOTHING = 0.0; 
const double INVERSE = -1.0; 
const int CURRENCY_FORMAT = 2; 

void main() 
{ 
    Menu(); 
} 

void Menu() 
{ 
    // Create complex numbers to do arithmentic with 
    ComplexNumber cm1(1, 2); 
    ComplexNumber cm2(1, -2); 

    // test addition operator 
    ComplexNumber cm3 = cm1 + cm2; 
    cout << cm3 << endl; 

    // test subtraction operator 
    ComplexNumber cm4 = cm1 - cm2; 
    cout << cm4 << endl; 

    // test multiplication operator 
    ComplexNumber cm5 = cm1 * cm2; 
    cout << cm5 << endl; 

    // test division operator 
    ComplexNumber cm6 = cm1/cm2; 
    cout << cm6<< endl; 

    // test assignment operator 
    cm6 = cm5; 
    cout << cm6 << endl; 

    // test comparison operator 
    if (cm1 == cm2) 
     cout << "\nThey are equal.\n"; 
    else 
     cout << "\nThey are not equal."; 

    ComplexNumber cm8(1, 2); 
    if (cm1 == cm8) 
     cout << "\nThey are equal.\n"; 
    else 
     cout << "\nThey are not equal."; 

    system ("PAUSE"); 
}

ComplexNumber::ComplexNumber() 
{ 
    _real = 0.0; 
    _imaginary = 0.0; 
} 

ComplexNumber::ComplexNumber(double initReal, double initImaginary) 
{ 
    _real = initReal; 
    _imaginary = initImaginary; 
} 

ComplexNumber::ComplexNumber(ComplexNumber& cmplx) 
{ 
    _imaginary = cmplx._imaginary; 
    _real = cmplx._real; 
} 

ComplexNumber ComplexNumber::operator+ (ComplexNumber x) 
{ 
    double newReal = _real + x._real; 
    double newImaginary = _imaginary + x._imaginary; 
    ComplexNumber temp(newReal, newImaginary); 
    return temp; 
} 

ComplexNumber ComplexNumber::operator- (ComplexNumber x) 
{ 
    double newReal = _real - x._real; 
    double newImaginary = _imaginary - x._imaginary; 
    ComplexNumber temp(newReal, newImaginary); 
    return temp; 
} 

ComplexNumber ComplexNumber::operator* (ComplexNumber x) 
{ 
    double newReal = 0.0; 
    double newImaginary = 0.0; 
    //(a+b)*(c+d) = ac+bc+ad+bd 
    newReal = newReal + (_real * x._real); 
    newImaginary = newImaginary + (_imaginary * x._real); 
    newImaginary = newImaginary + (_real * x._imaginary); 
    newReal = newReal + (INVERSE * (_imaginary * x._imaginary)); 
    ComplexNumber temp(newReal, newImaginary); 
    return temp; 
} 

ComplexNumber ComplexNumber::operator/ (ComplexNumber x) 
{ 
    double newReal = 0.0; 
    double newImaginary = 0.0; 
    ComplexNumber conjugate(x._real, (INVERSE * x._imaginary)); 
    ComplexNumber numerator = (*this * conjugate); 
    ComplexNumber denominator = (x * conjugate); 
    newReal = numerator._real/denominator._real; 
    newImaginary = numerator._imaginary/denominator._real; 
    ComplexNumber temp(newReal, newImaginary); 
    return temp; 
} 

ComplexNumber ComplexNumber::operator= (ComplexNumber x) 
{ 
    ComplexNumber temp(x._real, x._imaginary); 
    return temp; 
} 

bool ComplexNumber::operator== (ComplexNumber x) 
{ 
    if ((_real == x._real) && (_imaginary == x._imaginary)) 
    { 
     return true; 
    } 
    else 
    { 
     return false; 
    } 
} 

ostream& operator<< (ostream& out, ComplexNumber x) 
{ 
    out.setf(ios::fixed); 
    out.precision(CURRENCY_FORMAT); 
    if ((x._real != NOTHING) && (x._imaginary != NOTHING)) 
    { 
     if ((x._real > NOTHING) && (x._imaginary > NOTHING)) 
     { 
      out << x._real << " + " << x._imaginary << "i"; 
      return out; 
     } 
     else if ((x._real > NOTHING) && (x._imaginary < NOTHING)) 
     { 
      out << x._real << " - " << (INVERSE * x._imaginary) << "i"; 
      return out; 
     } 
     else if ((x._real < NOTHING) && (x._imaginary > NOTHING)) 
     { 
      out << x._real << " + " << x._imaginary << "i"; 
      return out; 
     } 
     else 
     { 
      out << x._real << " - " << (INVERSE * x._imaginary) << "i"; 
      return out; 
     } 
    } 
    else if ((x._real == NOTHING) && (x._imaginary != NOTHING)) 
    { 
     out << x._imaginary << "i"; 
     return out; 
    } 
    else if ((x._real != NOTHING) && (x._imaginary == NOTHING)) 
    { 
     out << x._real; 
     return out; 
    } 
    else 
    { 
     out << NOTHING; 
     return out; 
    } 
}

来源

2013-12-19 user3117263

'main'必须返回'int'的。而且从不**在标题中放置使用指令。您还应该从该运算符重载中返回一个引用，并实际修改该对象。说到这些，其他的像'operator /'不会修改对象，所以它们应该被标记为'const'。 – chris

请得到一个体面的C++教科书。你的代码中有一些令人头痛的严重错误。 –

Kerrek是对的，我不能再感觉到我的头了。 –

你的赋值运算符签名的声明应该是

ComplexNumber& operator= (const ComplexNumber&);

，并返回一个引用当前实例：

ComplexNumber& operator= (const ComplexNumber& other) 
{ 
    // copy members from other ... 
    return *this; 
}

...当中有很多你会遇到其他错误你码。

来源

2013-12-19 00:07:42

谢谢！看起来我有更多的重读操作符，哈哈。 – user3117263

@ user3117263很高兴有帮助;）... –

复制构造函数应该采取const&而不是&。

operator=应修改this状态。

你的流是丑陋的，你不应该用这种方式搞砸精度。设置外部精度。它可能有其他问题。

一元-在许多方面比*INVERSE更好。

因各种原因摆脱NOTHING，其中包括0.0。

来源

2013-12-19 00:15:30 Yakk

你所做的就是你所得到的。您无法更改指定的对象。而是这个

ComplexNumber ComplexNumber::operator= (ComplexNumber x) 
{ 
    ComplexNumber temp(x._real, x._imaginary); 
    return temp; 
}

倒不如写的拷贝赋值运算符通过以下方式

ComplexNumber & ComplexNumber::operator= (const ComplexNumber &x) 
{ 
    if (this != &x) 
    { 
     _real = x._real; 
     _imaginary = x._imaginary; 
    } 

    return (*this); 
}

来源

2013-12-19 00:28:20

问题与重载分配运算符

回答

相关问题