클래스의 멤버를 참조하는 . 연산자는 워낙 기본 연산자라 오버로딩
금지되어 있다. 그러나 객체 포인터로부터 멤버를 읽는 -> 연산자는
오버로딩 가능하다. 다른 연산자와 달리 특수한 규칙이 적용되는데 원래 이항 연산자지만 오버로딩하면 단항
연산자가 되며 멤버 함수로만 구현할 수 있다. 따라서 인수를 취하지 않는다.
리턴 타입도 제약이 있어 객체의 포인터만 리턴할 수 있다. 오버로딩
용도가 미리 정해져 있는 셈인데 포함 객체의 번지를 리턴하여 내부 멤버를 대신 읽어주는 역할을 한다. 포함
객체의 멤버를 읽으려면 두 번 연거푸 . 연산자를 적용해야 하지만
-> 연산자를 오버로딩하면 직접 액세스할 수 있다.
|
MemberAccessOp |
#include <stdio.h>
#include <string.h>
struct Author {
char
name[32];
int
age;
};
class Book
{
private:
char
title[32];
Author
writer;
public:
Book(const
char *aTitle, const char *aName, int aAge) {
strcpy(title,
aTitle);
strcpy(writer.name,
aName);
writer.age
= aAge;
}
Author
*operator->() { return &writer; }
const
char *GetTitle() { return title; }
};
int main()
{
Book
android("안드로이드 정복", "김상형", 29);
printf("제목:%s, 저자:%s, 저자 나이:%d세\n",
android.GetTitle(),
android->name, android->age);
}
|
실행결과 |
제목:안드로이드 정복, 저자:김상형, 저자 나이:29세 |
Author 클래스는 저자의 신상 정보를 표현한다. Book 클래스는 책에 대한 정보를 표현하는데 저자에 대한 정보를
Author 타입의 writer 멤버에 저장한다.
Book 클래스에 Author 클래스의 객체가 중첩되어 있는 형태이다. Book 타입의 객체 android에서 저자의 이름을 알고 싶다면
원래 다음과 같이 액세스해야 한다.
android.writer.name
객체가 중첩되어 있으니 . 연산자도 두 번 사용하는 것이 원칙이다. 그러나 매번 이렇게 쓰기는 불편하고 비효율적이다. 게다가 포함 객체의
숨겨진 멤버를 외부에서 마음대로 읽을 수도 없다. 그래서 -> 연산자를
포함 객체인 write의 번지를 리턴하도록 정의했다. -> 연산자의
좌변은 원래 객체 포인터가 와야 하지만 오버로딩하면 객체가 와도 상관없다. 이제 포함 객체의 멤버를
다음과 같이 액세스하면 된다.
android->name
-> 연산자가 writer 객체의
포인터를 리턴하므로 뒤에 바로 Author의 멤버를 쓰면 된다.
name은 Book의 멤버가 아니지만 마치 자신의 멤버처럼 액세스할 수 있으며 숨겨진 멤버까지도
읽을 수 있다.
일반적인 용도로는 잘 사용하지 않으며 대형 라이브러리를 작성할 때 객체를 래핑한 클래스를 래핑된 객체처럼 바로
사용할 수 있도록 해 준다. 이런 것을 스마트 포인터라고 하는데 포인터의 유효성 검사나 사용 카운트를
관리하는 역할을 한다.
괄호()도 일종의 연산자이며 오버로딩 대상이다. 인수의 개수가 정해져 있지 않아 임의의 연산자를 취할 수 있다는 것이 특징이며 인수의 개수나 타입에 따라 원하는대로
얼마든지 오버로딩할 수 있고 인수의 디폴트값을 줄 수도 있다.
|
FunCallOp |
#include <stdio.h>
class Sum
{
public:
int
operator()(int a, int b, int c, int d) {
return
a + b + c + d;
}
double
operator()(double a, double b) {
return
a + b;
}
};
int main()
{
Sum s;
printf("1
+ 2 + 3 + 4 = %d\n", s(1, 2, 3, 4));
printf("1.2
+ 3.4 = %f\n", s(1.2, 3.4));
}
|
실행결과 |
1 + 2 + 3 + 4 = 10 1.2 + 3.4 = 4.600000 |
Sum 클래스는 정수 4개의
합을 구하는 ( ) 연산자와 실수 2개의 합을 구하는 ( ) 연산자를 정의한다. main에서 Sum 타입의 객체 s를 생성하고
s로부터 ( ) 연산자를 호출한다. s(...) 표현식은
클래스명이 아닌 객체명으로 호출하므로 생성자 호출문이 아니라 연산자 함수 호출문이다. 컴파일러는 ( )의 인수열을 보고 적절한 연산자 함수를 찾아 호출한다.
Sum에는 별도의 멤버가 없고 오로지 ( ) 연산자만 정의되어 있다. 그래서 객체를 생성할 필요없이 임시객체로부터 ( ) 연산자를 호출해도 잘 동작한다.
printf("1 + 2 + 3 + 4 = %d\n",
Sum()(1, 2, 3, 4));
printf("1.2 + 3.4 = %f\n",
Sum()(1.2, 3.4));
Sum()은 디폴트 생성자를 호출하여 임시 객체를 만들며 이 객체의 ( ) 연산자 함수를 호출한다. 임시 객체는 함수가 종료될 때 자동으로
파괴된다. 항상 객체로부터 호출되므로 전역 함수로는 정의할 수 없으며 멤버 함수로만 정의할 수 있다.
( ) 연산자는 피연산자의 개수에 제약이 없어 입력을 얼마든지 받아들일
수 있다. C 언어의 연산자는 최대 3개까지의 인수만 받지만 ( ) 연산자는 콤마로 구분만 하면 필요한만큼 인수를 받는다.
|
ScoreManager |
#include <stdio.h>
#include <memory.h>
class ScoreManager
{
private:
// 성적을
저장하는 여러 가지 멤버 변수들
int
ar[3][5][10][4];
public:
ScoreManager()
{ memset(ar, 0, sizeof(ar)); }
int
&operator()(int Grade, int Class, int StNum, const char *Subj) {
return
ar[Grade][Class][StNum][0];
}
const
int &operator()(int Grade, int Class, int StNum, const char *Subj) const {
return
ar[Grade][Class][StNum][0];
}
};
int main()
{
ScoreManager
sm;
printf("1학년 2반 3번 학생의 국어 성적 =
%d\n", sm(1, 2, 3, "국어"));
sm(2,
3, 4, "산수") = 99;
}
ScoreManager 클래스는 성적을 관리하는데 성적 조사를 위해
학년, 반, 번호, 과목의 4가지나 되는 입력이 필요하다. ( ) 연산자는 이 모든 정보를 입력받아
내부 자료로부터 원하는 성적을 조사하여 리턴한다. 이렇게 조사된 성적은 좌우변에 모두 사용할 수 있어야
하므로 상수 버전과 비상수 버전을 각각 제공한다. ( ) 연산자가 리턴한 값을 읽을 수도 있고 ( ) 연산자가 리턴한 대상을 바꿀 수도 있다.
클래스는 속성과 동작을 가짐으로써 세상의 모든 사물을 다 흉내낼 수 있다. 포인터를
래핑하거나 함수를 래핑하기도 하는데 함수를 흉내내는 클래스를 정의할 때 ( ) 연산자를 사용한다. 위 예제의 sm 객체는 마치 함수처럼 동작한다. 이처럼 함수를 흉내내는 클래스를 함수 객체(Functor)라고 하는데
일반화된 알고리즘의 동작에 변화를 주기 위해 흔히 사용된다.
new 연산자는 객체를 위한 힙을 할당한 후 생성자를 호출하여 초기화하고 delete 연산자는 파괴자를 호출한 후 메모리를 회수한다. 객체를
만들 때 생성자를 호출하는 동작은 언어가 규정한 것이어서 오버로딩 대상이 아니다. 그러나 메모리를 할당, 해제하는 동작은 오버로딩할 수 있다.
즉 new 연산자는 오버로딩할 수 없지만 이 함수가 메모리 할당을
위해 내부적으로 호출하는 operator new는 오버로딩 가능하다.
기법에 비해 실용성이 높지 않으므로 두 연산자를 오버로딩하는 예만 살펴 보자.
|
newOverload |
#include <stdio.h>
#include <malloc.h>
void *operator new(size_t t)
{
return
malloc(t);
}
void operator delete(void *p)
{
free(p);
}
int main()
{
int
*pi = new int;
*pi =
1234;
printf("%d\n",
*pi);
delete
pi;
}
|
실행결과 |
1234 |
new 연산자는 malloc을
호출하여 C 형식으로 메모리를 할당하고 delete는 free를 호출하여 메모리를 해제한다. 메모리 할당, 해제 방식만 바꾸었을 뿐 생성자, 파괴자의 호출을 생략한 것은 아니다. new int(1234)로 호출하면 생성과 동시에 초기화도 잘 된다. 배열을
할당하는 new [], delete [] 도 물론 오버로딩할 수 있다.
이 예제는 두 연산자를 오버로딩할 수 있다는 것만 확인해 봤는데 얼마든지 다른 할당 방식을 사용할 수 있다. Win32의 가상 메모리를 활용하면 예약과 확정 단계를 통해 메모리를 섬세하게 관리할 수 있고 각 메모리에
권한을 다르게 지정할 수도 있다. 또 메모리 할당, 해제가
빈번하다면 메모리 풀을 마련하여 객체끼리 돌려가며 쓰는 방식으로 단편화를 방지하기도 한다.
이 연산자를 제대로 정의하기 위해서는 C++ 문법보다는 운영체제의
메모리 관리 기법을 정확하게 구사해야 한다. 언어가 제공하는 메모리 관리 기능에 비해 운영체제가 제공하는
메모리 관리 기능은 수준이 다르다. 고도의 메모리 관리가 필요할 때 이 연산자를 오버로딩하되 실제 그렇게까지
할 경우는 흔하지 않다.