Complex6 (inline 함수)

<main.cpp>

#include <iostream>

#include "complex.h"



int main()

{

	Complex c1(3.0, 4.0);       // (3.0, 4.0i)

	Complex c2(3.0);            // (3.0, 0.0i)

	//Complex c2 = 3.0;         // implicit conversion good!

	Complex c3;                 // (0.0, 0.0i)

	const Complex c4 = c1;

	

	c2 = c1;

	c2.real(c1.real());

	c2.imag(c1.imag());

	

	std::cout << "c1 : (" << c1.real() << ", " << c1.imag() << "i)" << std::endl;

	

	c3 = c1 + c2;     // c1.operator+(c2); or operator(c1, c2);

	c3 = c1 - c2;

	

	c1 += c2;

	c1 -= c2;

	

	c1 > c2;

	c1 < c2;

	c1 >= c2;

	c1 <= c2;

	

	if (c1 == c2)

	{

		std::cout << "c1 and c2 are equal" << std::endl;

	}

	else

	{

		std::cout << "c1 and c2 are not equal" << std::endl;

	}

	

	c1 != c2;

	

	std::cin >> c3;

	

	std::cout << "c1 : " << c1 << std::endl;

	std::cout << "c2 : " << c2 << std::endl;

	std::cout << "c3 : " << c3 << std::endl;

	std::cout << "c4 : " << c4 << std::endl;

	

	return 0;

}

<complex.h>

#ifndef COMPLEX_H

#define COMPLEX_H

#include <iostream>



class Complex {

friend std::istream& operator>>(std::istream& in, Complex& rhs);

friend std::ostream& operator<<(std::ostream& out, const Complex& rhs);



private:

	double re_;

	double im_;

	

public:

	//Complex *operator&() { return *this; }

	//const Complex *operator&() const { return *this; }

	

	//Complex();

	//Complex(double re);       /* explicit X */

	Complex(double re = 0.0, double im = 0.0);

	//Complex(const Complex& rhs) { /*memberwise copy*/ }

	//~Complex() {}

	

	//Complex& operator=(const Complex& rhs) { /*memberwise*/ return *this; }

	

	Complex& operator+=(const Complex& rhs);

	Complex& operator-=(const Complex& rhs);

	//Complex& operator*=(const Complex& rhs);     // is not implemented

	//Complex& operator/=(const Complex& rhs);     // is not implemented

	

	const Complex operator+(const Complex& rhs) const;

	const Complex operator-(const Complex& rhs) const;

	//const Complex operator*(const Complex& rhs) const;     // is not implemented

	//const Complex operator/(const Complex& rhs) const;     // is not implemented

	

	bool operator==(const Complex& rhs) const;

	bool operator!=(const Complex& rhs) const;

	bool operator>(const Complex& rhs) const;

	bool operator<(const Complex& rhs) const;

	bool operator>=(const Complex& rhs) const;

	bool operator<=(const Complex& rhs) const;

	

	double real() const;

	double imag() const;

	

	void real(double re);

	void imag(double im);

	

};



inline Complex::Complex(double re, double im)

: re_(re), im_(im)

{

	

}



inline double Complex::real() const

{

	return re_;

}



inline double Complex::imag() const

{

	return im_;

}



inline void Complex::real(double re)

{

	re_ = re;

}



inline void Complex::imag(double im)

{

	im_ = im;

}



#endif

<complex.cpp>

#include "complex.h"



std::istream& operator>>(std::istream& in, Complex& rhs)

{

	double re = 0.0, im = 0.0;

	

	char c = 0;

	in >> c;

	

	if (c == '(')

	{

		in >> re >> c;

		

		if (c == ',') in >> im >> c;

		if (c == 'i') in >> c;

		if (c != ')') in.clear(std::ios::failbit);

	}

	else

	{

		in.putback(c);

		in >> re;

	}

	

	if (in )

	{

		rhs = Complex(re, im);

	}

	

	return in;

}



std::ostream& operator<<(std::ostream& out, const Complex& rhs)

{

	out << "(" << rhs.re_ << ", " << rhs.im_ << "i)";

	

	return out;

}



/*

Complex::Complex()

: re_(0.0), im_(0.0)

{



}



Complex::Complex(double re)

: re_(re), im_(0.0)

{



}

*/



Complex& Complex::operator+=(const Complex& rhs)

{

	return *this = *this + rhs;

}



Complex& Complex::operator-=(const Complex& rhs)

{

	return *this = *this - rhs;

}



const Complex Complex::operator+(const Complex& rhs) const

{

	Complex result(re_ + rhs.re_, im_ + rhs.im_);

	

	return result;

}



const Complex Complex::operator-(const Complex& rhs) const

{

	Complex result(re_ +- rhs.re_, im_ - rhs.im_);

	

	return result;

}



bool Complex::operator==(const Complex& rhs) const

{

	return re_ == rhs.re_ && im_ == rhs.im_;

}



bool Complex::operator!=(const Complex& rhs) const

{

	//return re_ != rhs.re_ || im_ != rhs.im_;

	//return !this->operator==(rhs);

	return !(*this == rhs);

}



bool Complex::operator>(const Complex& rhs) const

{

	//return sqrt(re_ * re_ + im_ * im_) > sqrt(rhs.re_ * rhs.re_ + rhs.im_ * rhs.im_);

	return re_ * re_ + im_ * im_ > rhs.re_ * rhs.re_ + rhs.im_ * rhs.im_;

}



bool Complex::operator<(const Complex& rhs) const

{

	return re_ * re_ + im_ * im_ < rhs.re_ * rhs.re_ + rhs.im_ * rhs.im_;

}



bool Complex::operator>=(const Complex& rhs) const

{

	return !this->operator<(rhs);

}



bool Complex::operator<=(const Complex& rhs) const

{

	return !this->operator>(rhs);

}

 

<compile 결과>