C++ 11. 연산자 중복(오버로딩)

title: “C++ 11. 연산자 중복(오버로딩)” categories:

CspecialCharspecialChar

#C++ 11. 연산자 중복(오버로딩) : 네이버 블로그

연산자 중복(재정의)/오버로딩

연산자 중복은 연산자를 재정의해 사용자 지정 연산자를 만든다는 뜻이다

c++에서는 클래스에 연산자 중복을 사용하여 클래스의 연산자를 만들 수 있다

연산자 중복은 operator 함수를 사용하게 된다

리턴타입 operator 연산자(매개변수리스트);

의 형식으로 선언된다

클래스의 연산자 중복을 하는 경우는 2가지가 있다

클래스 내부에서 연산자 중복 맴버를 가지는 경우
클래스 외부에서 프랜드로 내부 데이터에 접근해 연산자 중복을 하는 경우

먼저 1. 클래스 맴버로 연산자 중복에 대해 알아보겠다

#include
using namespace std;
class xy {
 int x, y;
public:
 xy(int x, int y) {
 this->x = x;
 this->y = y;
 }
 void showxy() {
 cout << this->x <y << endl;
 }
 xy operator+(xy A) {
 xy R(0, 0);
 R.x = this->x + A.x;
 R.y = this->y + A.y;
 return R;
 }
};
int main() {
 xy A(1, 1);
 xy B(2, 2);
 xy C(0, 0);
 C = A + B;
 C.showxy();
}

한줄씩 가보자

일단 class xy가 정의되어 있다

xy는 xy 값을 가지고 있으며

show는 xy값을 출력한다

중요한 xy operator+(xy A)은

xy로 리턴하고 +연산자를 통해 오른쪽 피연산자가 A로 전달된다

이후 메인에서

C=A+B;에서 A+를 통해 재정의된 연산자가 실행되고

A+뒤에 있는 피연산자 B가

클래스 내부에 있는 A로 들어간다(xy operator+(xy A)에서 A)

중요한 점은 A에서 실행이 되었기 때문에 R.x=this->x+A.x;이 된다

조금 혯갈리게 됬는데 어쨋거다 뒤에 오는 얘가 피연산자고 앞에 있는얘가 operator를 실행하는것을 주의해야 한다

#include
using namespace std;
class xy {
 int x, y;
public:
 xy(int x, int y) {
 this->x = x;
 this->y = y;
 }
 void showxy() {
 cout << this->x <y << endl;
 }
 void operator!() {
 xy R(0, 0);
 if (x == 1)
 cout << "x=1"<<endl;
 if (y == 1) {
 cout << "y=1"<<endl;
 }

 }
};
int main() {
 xy a(1, 1);
 !a;
}

위 코드는 피연산자가 하나인 중복 연산자이다

operator! 을 통해 x=1,y=1이면 출력한다

main 안애서 연산자 실행은 !a를 통해 실행된다

주의할점은 피연산자가 자신만 있을 경우 연산자를 쓴 후 뒤에 객체가 온다( !a )

마찬가지로 다른 연산자를 사용하더라도 연산자가 앞에 온다(++a,–a,!@#a)

그럼 연산자를 뒤로 보내기 위해서는 어떻게 해야 할까?

바로 피연산자에 (int)를 추가하면 된다

void operator++(int)

이렇게 하면 a++를 사용할 수 있다

int는 매개변수로 int형을 전달한다는 것이 아닌 전위/후위 연산자를 구분하기 위함이다

(시험에 나올거같다ㅋㅋ)

잊지말자 operator++(int) !

그럼 첫번째 방법 클래스 내에 함수를 추가해 연산자 중복을 했고

두번째 방법. 프랜드로 외부 함수가 객체 내에 접근해 연산한다!

이해가 잘 안가려나?

음… 일단 아래 코드를 보자

#include
using namespace std;
class xy {
 int x, y;
public:
 xy(int x, int y) {
 this->x = x;
 this->y = y;
 }
 void showxy() {
 cout << this->x <y << endl;
 }
 friend xy operator+(xy a, xy b);
};
xy operator+(xy a, xy b) {
 xy c(0, 0);
 c.x = a.x + b.x;
 c.y = a.y + b.y;
 return c;
}
int main() {
 xy a(1, 1);
 xy b(2, 2);
 xy c(0, 0);
 c = a + b;
 c.showxy();
}

무엇이 달라졌는지 알겠는가?

friend xy operator+(xy a, xy b); 가 들어갔는데 +자체가 함수 이름이 되어

외부에서 xy operator+(xy a, xy b)를 구현할 수 있다

즉 operator+ 자체가 함수 이름이 되는 것이다

그리고 프랜드로 operator+는 함수 내부 맴버에 접근할 수 있

#include
using namespace std;
class xy {
 int x, y;
public:
 xy(int x, int y) {
 this->x = x;
 this->y = y;
 }
 void showxy() {
 cout << this->x <y << endl;
 }
 friend void operator!(xy A);
};
void operator!(xy A) {
 if (A.x == 1)
 cout << "x=1" << endl;
 if (A.y == 1)
 cout << "y=1" << endl;
}
int main() {
 xy a(1, 1);
 !a;
}

무엇을 설명하려 하는지 알겠는가?

이번엔 operator!를 사용하고 매개 변수는 A이다

이후 메인 안에서는 !a를 이용해 operator를 실행시킨다

그럼 마찬가지로 a++처럼 연산자를 뒤로 보내기 위해서는 어떻게 해야 할까?

마찬가지로 (int)를 피연산자로 추가해주면 된다

#include
using namespace std;
class xy {
 int x, y;
public:
 xy(int x, int y) {
 this->x = x;
 this->y = y;
 }
 void showxy() {
 cout << this->x <y << endl;
 }
 friend void operator++(xy A,int x);
};
void operator++(xy A,int x) {
 if (A.x == 1)
 cout << "x=1" << endl;
 if (A.y == 1)
 cout << "y=1" << endl;
}
int main() {
 xy a(1, 1);
 a++;
}

지금 와서 알게되었는데 (int x)를 사용하여 연산자를 뒤로 사용하게 되면 ++나 –만을 연산자로 사용해야 한다

!,==이런건 안되는 것 같다. 아마 a++,a–들만을 위한 (int)같다

CspecialCharspecialChar