Operator overloading

프로그래밍 언어/CPP 2014. 7. 11. 01:25

Class에 +,- 등의 연산자를 쓸 수 있게 하는 문법

#include <iostream>

using namespace std;
class overloading
{
public:
	int x;
	int y;

overloading(int _x = 0, int _y = 0):x(_x),y(_y){}
	void Print() const { std::cout << x << ",\t" << y << std::endl;}
	overloading operator+(overloading& a)
	{
		return overloading(x+a.x, y+a.y);
	}

overloading operator+(int a)
	{
		return overloading(x+a, y+a);
	}

bool operator==(const overloading& a) { return( (x==a.x)&&(y==a.y) ); }

// ++this
	const overloading& operator++() 
	{
             x++;
             y++;
             return *this;
	}

// this++
	const overloading& operator++(int)
	{
         overloading temp(x, y);
         x++;
         y++;
         return temp;
	}

// this()
	void operator()()
	{
		Print();
	}

// this[index]
	int operator[](int idx)
	{
		if( idx == 0) {std::cout << " x : " << x << std::endl;return x;}
		else 
			std::cout << " y : " << y << std::endl;
		return y;
	}

// (int)this
	operator int()
	{ cout << "type int" << endl; return x;}
};

// Smart overloading
class overloadingPtr
{
	overloading *ptr;
public:

explicit overloadingPtr(overloading* p):ptr(p){}
	~overloadingPtr()
	{
		if( ptr != NULL)
			delete ptr;
	}
	overloading* operator->()
	{ return ptr; }

overloading& operator*()
	{
		return *ptr;
	}
};

// 전역 오버로딩
const overloading operator*(const overloading& a, const overloading& b)
{
	int x;
	int y;

x = a.x*b.x;
	y = a.y*b.y;
	return overloading(x,y);
}

const overloading operator*(const int& a, const overloading& b)
{
	int x;
	int y;

x = a*b.x;
	y = a*b.y;
	return overloading(x,y);
}

int main_Overloading()
{
	overloading a(12,13), b(15,16);
	
	a.Print();
	b.Print();

std::cout << "--------------" << std::endl;

a.operator+(b);
	(a+b).Print();
	
	operator*(a,b);
	(a*b).Print();
	
	a.operator+(10);
	(a+10).Print();
	
	operator*(10,a);
	(10*a).Print();

a++;
	a.Print();

++a;
	a.Print();

if( a==b)
		a.Print();
	else
		std::cout << "a, b different" << std::endl;

// operator()
	a();