ex02(비교, 산술, 증감 연산자 오버로딩)

• 이 문제는 비교, 산술, 증감 연산자를 오버로딩 해보는 문제이다.

연산자 오버로딩

→ 간단하게 말해서 우리가 알고 있는 +, -, *, / 에서부터 ++, --, [], <, > ==, =등 다양한 연산자들을 우리가 재정의해서 사용할 수 있게 해주는 방법.

아 근데 이 짓을 왜 해야되냐?

• 컴파일러는 우리가 만든 객체의 연산을 이애하지 못함. 우리가 객체를 만들고, 그 값들을 사용하는데 기본적인 연산자를 사용하지 못 하면 오바이긴 하니,, 우리가 만든 객체들의 연산자들의 정의를 우리가 직접 정의해서 객체끼리의 연산을 가능하도록 만든 거임.

연산자 오버로딩의 제한

→ 오버로딩이 가능한 연산자가 있고 불가능한 연산자들이 있다. 이유는 기본적인 C++의 문법이 어긋날 수 있기 때문

 

Fixed.hpp

#ifndef FIXED_HPP
# define FIXED_HPP

# include <iostream>

class Fixed{
private:
	const static int bits = 8;
	int	number;
public:
	Fixed();
	Fixed(const Fixed &obj);
	Fixed(int num);
	Fixed(const float num);
	Fixed& operator=(const Fixed &obj);
	float toFloat( void ) const;
	int toInt( void ) const;
	~Fixed();
	int getRawBits(void) const;
	void setRawBits(int const raw);

	bool operator>(Fixed const &obj) const;
	bool operator<(Fixed const &obj) const;
	bool operator>=(Fixed const &obj) const;
	bool operator<=(Fixed const &obj) const;
	bool operator==(Fixed const &obj) const;
	bool operator!=(Fixed const &obj) const;

	Fixed operator+ (const Fixed &obj);
	Fixed operator- (const Fixed &obj);
	Fixed operator* (const Fixed &obj);
	Fixed operator/ (const Fixed &obj);

	Fixed	&operator++(void);
	const Fixed	operator++(int);
	Fixed	&operator--(void);
	const Fixed	operator--(int);

	static Fixed	&min(Fixed &left, Fixed &right);
	static const Fixed	&min(Fixed const &left, Fixed const &right);
	static Fixed	&max(Fixed &left, Fixed &right);
	static const Fixed	&max(Fixed const &left, Fixed const &right);

};
std::ostream &operator<<(std::ostream &out, const Fixed &obj);
# endif

Fixed.cpp

#include "Fixed.hpp"

Fixed::Fixed(void)
{
	this->number = 0;
}

Fixed::Fixed(const Fixed &obj)
{
	*this = obj;
}

Fixed::Fixed(int num)
{
	this->number = num << this->bits;
}

Fixed::Fixed(const float num)
{
	this->number = roundf(num * (1 << this->bits));
}

float Fixed::toFloat(void) const 
{
	return ((float)this->number / (1 << this->bits)); 
}

int Fixed::toInt(void) const 
{
	return (this->number >> this->bits);
}

std::ostream &operator<<(std::ostream &out, const Fixed &obj)
{
	out << obj.toFloat();
	return (out);
}

Fixed& Fixed::operator=(const Fixed &obj)
{
	if (this == &obj)
		return *this;
	this->number = obj.getRawBits();
	return *this;
}

Fixed::~Fixed(void)
{
}

int	Fixed::getRawBits(void) const
{
	return (this->number);
}

void	Fixed::setRawBits(int const raw)
{
	this->number = raw;
}

bool Fixed::operator>(Fixed const &obj) const
{
	return (this->getRawBits() > obj.getRawBits());
}

bool Fixed::operator<(Fixed const &obj) const
{
	return (this->getRawBits() < obj.getRawBits());
}

bool Fixed::operator>=(Fixed const &obj) const
{
	return (this->getRawBits() >= obj.getRawBits());
}

bool Fixed::operator<=(Fixed const &obj) const
{
	return (this->getRawBits() <= obj.getRawBits());
}

bool Fixed::operator==(Fixed const &obj) const
{
	return (this->getRawBits() == obj.getRawBits());
}

bool Fixed::operator!=(Fixed const &obj) const
{
	return (this->getRawBits() != obj.getRawBits());
}

Fixed Fixed::operator+ (const Fixed &obj)
{
	return Fixed(this->toFloat() + obj.toFloat());
}

Fixed Fixed::operator- (const Fixed &obj)
{
	return Fixed(this->toFloat() - obj.toFloat());
}

Fixed Fixed::operator* (const Fixed &obj)
{
	return Fixed(this->toFloat() * obj.toFloat());
}

Fixed Fixed::operator/ (const Fixed &obj)
{
	return Fixed(this->toFloat() / obj.toFloat());
}

Fixed&	Fixed::operator++(void)
{
	this->number++;
	return (*this);
}

const Fixed	Fixed::operator++(int)
{
	const Fixed	fixed(*this);

	this->number++;
	return (fixed);
}

Fixed&	Fixed::operator--(void)
{
	this->number--;
	return (*this);
}

const Fixed	Fixed::operator--(int)
{
	const Fixed	fixed(*this);

	this->number--;
	return (fixed);
}

Fixed&	Fixed::min(Fixed &left, Fixed &right)
{
	if (left <= right)
		return left;
	else
		return right;
}

const Fixed& Fixed::min(Fixed const &left, Fixed const &right)
{
	if (left <= right)
		return left;
	else
		return right;
}

Fixed&	Fixed::max(Fixed &left, Fixed &right)
{
	if (left >= right)
		return left;
	else
		return right;
}

const Fixed& Fixed::max(Fixed const &left, Fixed const &right)
{
	if (left >= right)
		return left;
	else
		return right;
}

main.cpp

#include "Fixed.hpp"

int main( void ) {
	Fixed a;
	Fixed const b( Fixed( 5.05f ) * Fixed( 2 ) );
	
	std::cout << a << std::endl;
	std::cout << ++a << std::endl;
	std::cout << a << std::endl;
	std::cout << a++ << std::endl;
	std::cout << a << std::endl;
	
	std::cout << b << std::endl;
	
	std::cout << Fixed::max( a, b ) << std::endl;
	
	return 0;
}

 

[ c++ ]연산자 오버로딩

[ c++ ]연산자 오버로딩