[C++] 연산자 오버로딩과 프렌드

 

 Test.h

#pragma once

class Test
{
public:
	Test();
	Test(int h, int m);
	~Test();

	void Add(int h, int m);
	void Print();
	void Reset() { minutes = 0; hours = 0; }
	Test operator+(const Test& t) const;

private:
	int minutes;
	int hours;

};

Test.cpp

#include <iostream>
#include "Test.h"

Test::Test()
{
	minutes = 0, hours = 0;
}

Test::Test(int h, int m)
	: minutes(m), hours(h)
{

}

Test::~Test()
{

}

void Test::Add(int h, int m)
{
	hours += h;

	minutes += m;
	hours += minutes / 60;
	minutes %= 60;
}

void Test::Print()
{
	std::cout << hours << "h " << minutes << "m\n";
}

Test Test::operator+(const Test& t) const
{
	Test sum;
	sum.minutes += minutes + t.minutes;
	sum.hours += hours + t.hours + sum.minutes / 60;
	sum.minutes %= 60;

	return sum;
}

Main.cpp

#include <iostream>
#include "Test.h"

using namespace std;


int main()
{
    Test save;

    Test n[3];
    n[0].Add(2, 30);
    n[1].Add(3, 45);
    n[2].Add(6, 32);

    save = n[2].operator+(n[1]);	//방법1
    save.Print();

    save = n[0] + n[1];	//방법2

    save.Print();


	return 0;
}

- operator를 이용하여 연산자 오버로딩을 만들 수 있다.

- +일때는 operator+(), *일때는 operator*등으로 만들 수가 있다.

- 함수내의 내용을 인터페이스에서 알 수 없으므로 신중해야된다. 각 객체의 멤버들이 서로 교환되면 안 된다.

- 객체내의 값들이 바뀌지 않도록 함수const를 사용한다.

 

 

프렌즈 함수

코드 더보기

Test.h

//Test.h
#pragma once

class Test
{
public:
	Test();
	Test(int h, int m);
	~Test();

	void Add(int h, int m);
	void Print();
	void Reset() { minutes = 0; hours = 0; }
	Test operator+(const Test& t) const;
	Test operator*(double x) const;
	friend Test operator*(double x, const Test& t);

private:
	int minutes;
	int hours;

};

Test.cpp

//Test.cpp
#include <iostream>
#include "Test.h"

Test::Test()
{
	minutes = 0, hours = 0;
}

Test::Test(int h, int m)
	: minutes(m), hours(h)
{

}

Test::~Test()
{

}

void Test::Add(int h, int m)
{
	hours += h;

	minutes += m;
	hours += minutes / 60;
	minutes %= 60;
}

void Test::Print()
{
	std::cout << hours << "h " << minutes << "m\n";
}

Test Test::operator+(const Test& t) const
{
	Test sum;
	sum.minutes += minutes + t.minutes;
	sum.hours += hours + t.hours + sum.minutes / 60;
	sum.minutes %= 60;

	return sum;
}

Test Test::operator*(double x) const
{
	Test result;
	long totalminutes = hours * x * 60 + minutes * x;
	result.hours = totalminutes / 60;
	result.minutes = totalminutes % 60;
	return result;
}

Test operator*(double x, const Test& t)
{
	return t * x;
}

Main.cpp

#include <iostream>
#include "Test.h"

using namespace std;


int main()
{
    Test save;

    Test n[3];
    n[0].Add(2, 30);
    n[1].Add(3, 45);
    n[2].Add(6, 32);

    save = n[0].operator*(2.8);	//Test Test::operator*(double x) const
    save.Print();
    
    save = n[1] * 3.6;	//Test Test::operator*(double x) const;
    save.Print();

    save = 2.4 * n[1];	//Test operator*(double x, const Test &t)
    save.Print();

    save = operator*(2.8, n[1]);	//Test operator*(double x, const Test &t)
    save.Print();
    
	return 0;
}

 

- 프렌즈 함수를 사용하여 곱셈의 경우에서 객체가 먼저가 아닌 실수가 먼저 대입할 수 있게 만든다.

- 하지만 t * x를 대입하기 위해서 기존의 operator*(double x) 함수가 필요하다.

- 함수에서 받아오는 매개변수의 순서를 바꾸기 위해서 사용하였다. 순서를 바꾸게 되면 실수가 앞으로 올 수 있게 만든다.

- C++에서 객체의 private 멤버에는 해당 객체의 public 멤버 함수를 통해서만 접근할 수 있습니다.

해당 객체의 멤버 함수가 아닌 함수도 private 멤버에 접근해야만 할 경우가 발생할 때 유용하게 사용할 수 있습니다.

 

operator<<()

//Test.h
friend std::ostream & operator<<(std::ostream &os, const Test& t);

//Test.cpp
std::ostream & operator<<(std::ostream & os, const Test& t)
{
	os << t.hours << "시간 " << t.minutes << "분";

	return os;
}

//Main.cpp
cout << "지금은 " << save;

- cout << save 호출은 cout 객체의 복사본이 아니라 그 자체를 사용해야 한다. 그렇기에 참조를 사용한다.

- void일경우 cout << save형만 가능한데 그 이유는 cout << x << y일때  c++은 마지막 출력 구문을 왼쪽부터 오른쪽으로 읽기 때문에 (cout << x)가 ostream의 객체여야한다. 하지만 void이기때문에 리턴형을 ostream &으로 해준다.

그렇게 되면 cout << .... << save의 순서가 되어도 사용이 가능하다. cout 객체를 리턴해주기 때문.

 

 

 

함수 const : https://chanheess.tistory.com/129

[C++] 클래스의 초기화, const 멤버 함수