main.cpp(complex클래스 증감연산자)

※main.cpp파일

#include <iostream>

#include "complex.h"



int main() {

	Complex c1;

	Complex c2 = 3.0;

	Complex c3(3.0,4.0);

	const Complex c4 = c3;    // Complex c4(c3)

	

	c1.real(c3.real());

	c1.imag(c3.imag());

	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;

	

	c1 != c3;

	c2 = c1 + c3;

	c2 = c1 - c3;

	

	++c1;

	c1++;

	

	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::ostream& operator<<(std::ostream& out,const Complex& rhs);

private:

	double re_;

	double im_;

public:

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

	double real() const;

	double imag() const;

	

	void real(double re);

	void imag(double im);

	

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

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



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

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

	const Complex& operator++();        // ++a

	const Complex operator++(int );    // a++

};



#endif

※complex.cpp파일

#include "complex.h"



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

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

	return out;

}



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

	re_ = re;   // this-> 는 생략가능(멤버변수와 함수의 지역변수 이름이 다를 때)

	im_ = im;

}



double Complex::real() const {

	return re_;

}



double Complex::imag() const {

	return im_;

}



void Complex::real(double re) {

	re_ = re;

}



void Complex::imag(double im) {

	im_ = im;

}



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

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

}



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

	return !this->operator==(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;

}



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

	re_ +=1.0;

	return *this;

}



const Complex Complex::operator++(int ) {

	Complex result = *this;

	re_ += 1.0;

	return result;

}