Complex2 (연산)

<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 + 0i
	Complex c3;			  // 0 + 0i

	//c3.real(c1.real());
	//c3.imag(c1.imag());

	c3 = c1;
	c2 = c1-c3;

	if (c1 == c3) 
    {
		std::cout <<"c1 and c3 are equal" << std::endl;
	} 
    else 
    {
		std::cout << "c1 and c3 are not equal" << std::endl;
	}

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

	return 0;
}

 

<complex.h>

#ifndef COMPLEX_H
#define COMPLEX_H

class Complex{
private:
	double re;   // real part
	double im;   // imaginary part

public:
	Complex(double re, double im);
	Complex(double re);
	Complex();
	~Complex();

	double real();
	double imag();
    
	void real(double re);
	void imag(double im);
	void operator=(const Complex &rhs);

	bool operator==(const Complex &rhs);

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



//Complex operator+(Complex lhs, Complex rhs);
//Complex operator+(const Complex *pc1, const Complex *pc2);
//Complex operator+(Complex &r1, Complex &r2);

#endif

 

<complex.cpp>

#include "complex.h"
//member function

/*Complex operator+(Complex lhs, Complex rhs)
{
	Complex result(lhs.real() + rhs.real(),lhs.imag() + rhs.imag());

	return result;
}*/

/*Complex operator+(const Complex *pc1, const Complex *pc2)
{
	Complex result(pc1->real() + pc2 ->real(), pc1->imag() + pc2->imag());
    
	return result;
}*/

/*Complex operator+(Complex &r1, Complex &r2)
{
	Complex result(r1.real()+r2.real(),r1.imag()+r2.imag());

	return result;
}*/

Complex::Complex()
{
	this->re = 0.0;
	this->im = 0.0;
}

Complex::Complex(double re)
{
	this->re = re;
	this->im = 0.0;	
}

Complex::Complex(double re, double im)
{
	this->re = re;
	this->im = im;
}

Complex::~Complex()
{	

}

void Complex::operator=(const Complex& rhs) 
{
	this->re = rhs.re;
	this->im = rhs.im;
}

bool Complex::operator==(const Complex &rhs) 
{
	/*if (this->re == rhs.re && this->im == rhs.im)
    {
		return true;
	} 
    else 
    {
		return false;
	}*/

	return (this->re == rhs.re && this->im == rhs.im);
}

double Complex::real()
{
	return this->re;
}

double Complex::imag()
{
	return this->im;
}

void Complex::real(double re) 
{
	this->re = re;
}

void Complex::imag(double im)
{
	this->im = im;
}

Complex Complex::operator+(const Complex &rhs) 
{
	Complex result(this->re  + rhs.re, this->im + rhs.im);

	return result;
}

Complex Complex::operator-(const Complex &rhs)
{
	Complex result(this->real()-rhs.re, this->imag()-rhs.im);

	return result;
}

 

<compile 결과>