#include <iostream>
// using namespace std;
using std::cout;
using std::endl;
using std::cin;
using std::istream;
using std::ostream;
class Complex {
public:
Complex(); // default constructor
Complex( double ); // constructor
Complex( double, double ); // constructor
Complex& operator=( const Complex& ); // overload the assignment operator
Complex& operator+=( const Complex& ); // overload operator +=
Complex& operator-=( const Complex& ); // overload operator -=
Complex& operator*=( const Complex& ); // overload operator *=
Complex& operator/=( const Complex& ); // overload operator /=
Complex& operator++(); // overload the prefix self-addition
Complex& operator--(); // overload the prefix self-subtration
Complex operator++( int ); // overload the suffix self-addition
Complex operator--( int ); // overload the suffix self-subtration
void print() const; // the function to output the complex
friend Complex operator+( const Complex&, const Complex& ); // overload the addition operator
friend Complex operator-( const Complex&, const Complex& ); // overload the subtration operator
friend Complex operator*( const Complex&, const Complex& ); // overload the multiplication operator
friend Complex operator/( const Complex&, const Complex& ); // overload the division operator
friend bool operator==( const Complex&, const Complex& ); // overload the equivalent operator
friend bool operator!=( const Complex&, const Complex& ); // overload the unequal operator
friend ostream& operator<<( ostream&, const Complex& );
friend istream& operator>>( istream&, Complex& );
private:
double real; // the real part of the complex
double imag; // the imaginary part of the complex
};
/**
* The default constructor to create a complex without parameter.
* Both the real part and imaginary part are made zero.
*
*/
Complex::Complex() {
real = 0;
imag = 0;
}
/**
* The constructor to create a complex with one paramater to set the real part,
* the imaginary part is made zero.
*/
Complex::Complex( double r ) {
real = r;
imag = 0;
}
/**
* The constructor to create a complex with two paramaters.
*/
Complex::Complex( double r, double i ) {
real = r;
imag = i;
}
/**
* The program is to overload the assignment operator with a paramater.
*
* @param t the complex to assign.
* @return the self object
*/
Complex& Complex::operator=( const Complex& t ) {
real = t.real; // assign the real part of the paramater to the object
imag = t.imag; // assign the imaginary part of the paramater to the object
return *this;
}
/**
* This program is to overload the operator +=,with a complex paramater.
*
* @param t the complex to be added to the objext
* @return self object
*/
Complex& Complex::operator+=( const Complex& t ) {
real = real + t.real; // add the real part of the paramater to the real part of the object
imag = imag + t.imag; // add the imaginary part of the paramater to the imaginary part of the object
return *this;
}
/**
* This program is to overload the operator -=,with a complex paramater.
*
* @param t the complex to be subtracted to the objext
* @return self object
*/
Complex& Complex::operator-=( const Complex& t ) {
real = real - t.real; // subtract the real part
imag = imag - t.imag; // subtract the imaginary part
return *this;
}
/**
* This program is to overload the operator *=,with a complex paramater.
*
* @param t the complex to be multiplied to the objext
* @return self object
*/
Complex& Complex::operator*=( const Complex& t ) {
double temp1; // the first intermediate variable
double temp2; // the second intermediate variable
temp1 = real;
temp2 = imag;
// calculate the result and set it to the object
real = temp1 * t.real - temp2 * t.imag;
imag = temp1 * t.imag + temp2 * t.real;
return *this;
}
/**
* This program is to overload the operator /=,with a complex paramater.
*
* @param t the complex to be divided to the objext
* @return self object
*/
Complex& Complex::operator/=( const Complex& t ) {
double temp1; // the first intermediate variable
double temp2; // the second intermediate variable
temp1 = real;
temp2 = imag;
// calculate the result and set it to the object
real = ( temp1 * t.real + temp2 * t.imag ) / ( t.real * t.real + t.imag * t.imag );
imag = ( temp2 * t.real - temp1 * t.imag ) / ( t.real * t.real + t.imag * t.imag );
return *this;
}
/**
* This program is to overload the operator prefix ++,without paramater.
*
* @return self object
*/
Complex& Complex::operator++() {
real++; // the real part add one
imag++; // the imaginary part add one
return *this;
}
/**
* This program is to overload the operator prefix --,without paramater.
*
* @return self object
*/
Complex& Complex::operator--() {
real--; // the real part minus one
imag--; // the imaginary part minus one
return *this;
}
/**
* This program is to overload the operator suffix ++,without paramater.
*
* @return the complex before add
*/
Complex Complex::operator++( int ) {
Complex temp( real, imag ); // set the real part and imaginary part to another complex object
real++; // the real part add one
imag++; // the imaginary add one
return temp;
}
/**
* This program is to overload the operator suffix --,without paramater.
*
* @return the object before minus
*/
Complex Complex::operator--( int ) {
Complex temp( real, imag ); // set the real part and imaginary part to another complex object
real--; // the real part minus one
imag--; // the imaginary part minus one
return temp;
}
/**
* This program is to overload the operator +,with tow complex paramaters.
*
* @param t the first addend
* @param u the second addend
* @return a complex object
*/
Complex operator+( const Complex& t, const Complex& u ) {
return Complex( t.real + u.real, t.imag + u.imag );
}
/**
* This program is to overload the operator -,with two complex paramaters.
*
* @param t the first subtrahend
* @param u the second subtrahend
* @return a complex object
*/
Complex operator-( const Complex& t, const Complex& u ) {
return Complex( t.real - u.real, t.imag - u.imag );
}
/**
* This program is to overload the operator *,with two complex paramaters.
*
* @param t the first multiplier
* @param u the second multiplier
* @return a complex object
*/
Complex operator*( const Complex& t, const Complex& u ) {
return Complex( t.real * u.real - t.imag * u.imag, t.real * u.imag + t.imag * u.real );
}
/**
* This program is to overload the operator /,with two complex paramaters.
*
* @param t the dividend
* @param u the divisor
* @return a complex object
*/
Complex operator/( const Complex& t, const Complex& u ) {
return Complex( ( t.real * u.real + t.imag * u.imag ) / ( u.real * u.real + u.imag * u.imag ), ( t.imag * u.real - t.real * u.imag ) / ( u.real * u.real + u.imag * u.imag ) );
}
/**
* This program is to overload the operator ==,with two complex paramaters.
* If both the real part and imaginary part are equal,return true;otherwise,
* return false.
*
* @param t the first complex to be compared
* @param u the second complex to be compared
* @return true or false
*/
bool operator==( const Complex& t, const Complex& u ) {
if ( t.real == u.real && t.imag == u.imag ) { // both the real part and imaginary part are equal
return true;
} // end if
else { // not both the real part and imaginary part are equal
return false;
} // end else
}
/**
* This program is to overload the operator !=,with two complex paramaters.
* If not both the real part and imaginary part are equal,return true;otherwise,
* return false.
*
* @param t the first complex to be compared
* @param u the second complex to be compared
* @return true or false
*/
bool operator!=( const Complex& t, const Complex& u ) {
return !( t == u );
}
ostream& operator<<( ostream& os, const Complex& c) {
os << c.real << "+" << c.imag << "i";
return os;
}
istream& operator>>( istream& is, Complex& c) {
is >> c.real >> c.imag;
return is;
}
/**
* This program is to output complex object in a format.
*/
void Complex::print() const {
cout << "(" <<real << "," << imag << ")" << endl;
}
int main()
{
Complex x( 1, 1 );
Complex x1( 1, 1 );
Complex y( 2, 2 );
Complex z( 4, 4 );
// invoke operator==
if( x == x1 ) {
cout << "The same!\n";
}
// invoke operator!=
if ( x != y ) {
cout << "Not same!\n";
}
// invoke operator=
cout << "\nBefore assign,x1=";
x1.print();
x1 = y;
cout << "After assign,x1=";
x1.print();
// invoke operator+=
cout << "\nBefore the operator+=\n";
cout << "x=";
x.print();
cout << "y=";
y.print();
x += y;
cout << "After x+=y\n";
cout << "x=";
x.print();
// invoke operator-=
cout << "\nBefore the operator-=\nx=";
x.print();
cout << "y=";
y.print();
x -= y;
cout << "After x-=y\nx=";
x.print();
// invoke operator*=
cout << "\nBefore the operator*=\nx=";
x.print();
cout << "y=";
y.print();
x *= y;
cout << "After x*=y\nx=";
x.print();
// invoke operator/=
cout << "\nBefore the operator/=\nx=";
x.print();
cout << "y=";
y.print();
x /= y;
cout << "After x/=y\nx=";
x.print();
// invoke operator+
cout << "\nInvoke the operator+\nx=";
x.print();
cout << "y=";
y.print();
z = x + y;
cout << "z=x+y=";
z.print();
// invoke operator-
cout << "\nInvoke the operator-\nx=";
x.print();
cout << "y=";
y.print();
z = x - y;
cout << "z=x-y=";
z.print();
// invoke operator*
cout << "\nInvoke the operator*\nx=";
x.print();
cout << "y=";
y.print();
z = x * y;
cout << "z=x*y=";
z.print();
// invoke operator/
cout << "\nInvoke the operator/\nx=";
x.print();
cout << "y=";
y.print();
z = x / y;
cout << "z=x/y=";
z.print();
// invoke operator prefix ++
cout << "\nInvoke the operator prefix++\nx=";
x.print();
z = ++x;
cout << "After z=++x,\nz=";
z.print();
cout << "x=";
x.print();
// invoke operator prefix --
cout << "\nInvoke the operator prefix--\nx=";
x.print();
z = --x;
cout << "After z=--x,\nz=";
z.print();
cout << "x=";
x.print();
// invoke operator suffix ++
cout << "\nInvoke the operator suffix++\nx=";
x.print();
z = x++;
cout << "After z=x++,\nz=";
z.print();
cout << "x=";
x.print();
// invoke operator suffix --
cout << "\nInvoke the operator suffix--\nx=";
x.print();
z = x--;
cout << "After z=x--,\nz=";
z.print();
cout << "x=";
x.print();
cin >> x;
cout << x << endl;
return 0;
}
