C++ Chapter 10-2 : 단항 연산자의 오버로딩

증가, 감소 연산자의 오버로딩

• ++ : 1 증가 연산자
• -- : 1 감소 연산자

#include <iostream>
using namespace std;

class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    { }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl;
    }
    Point& operator++()
    {
        xpos+=1;
        ypos+=1;
        return *this;
    }
    friend Point& operator--(Point &ref);
};

Point& operator--(Point &ref)
{
    ref.xpos-=1;
    ref.ypos-=1;
    return ref;
}

int main(void)
{
    Point pos(1, 2);
    ++pos;  //멤버함수 오버로딩, pos.operator++();
    pos.ShowPosition();
    --pos;  //전역함수 오버로딩, operator--(pos);
    pos.ShowPosition();

    ++(++pos);
    pos.ShowPosition();
    --(--pos);
    pos.ShowPosition();
    return 0;
}

[2, 3]
[1, 2]
[3, 4]
[1, 2]

 함수 operator ++와 operator--는 모두 객체 자신의 참조형을 반환하고 있기 때문에 아래 연산은 다음 순서로 진행된다.

++(++pos);
++(pos.operator++());
pos.operator++(연산이 1회 진행된 pos의 참조값);

--(--pos);
--(operator--(pos));
operator--(연산이 1회 진행된 pos의 참조값);

 

전위증가와 후위증가의 구분

 증감연산자는 전위(++n)와 후위(n++)로 나뉜다.

• 전위: 반환값이 연산을 진행한 후의 연산결과값
• 후위: 반환값이 연산을 진행하기 전의 연산결과값   

 이를 다음 간단한 예시로 설명할 수 있다.

#include <iostream>
using namespace std;

int main(void)
{
    int num1 = 10;
    int num2 = 10;
    cout<<num1++<<endl;	//후위증가, 출력 후 num의 값 증가
    cout<<++num2<<endl;	//전위증가, num의 값 증가 후 출력

    cout<<num1<<", "<<num2<<endl;
    return 0;
}

10
11
11, 11

 추가적으로 후위증가,감소를 연산자 오버로딩할 때 전위증가,감소와 구별되게 작성해야 하는데 이를 위해서 매개변수에 키워드 int를 추가하면 된다. 물론, int는 단순 구별을 목적으로 하기 때문에 int형 데이터를 받는다는 뜻이 아니다.   

 

 예제를 통해 더 자세히 살펴보자.

#include <iostream>
using namespace std;

class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y)
    { }
    void ShowPosition() const
    {
        cout<<'['<<xpos<<", "<<ypos<<']'<<endl;
    }
    Point& operator++() //전위증가
    {
        xpos+=1;
        ypos+=1;
        return *this;
    }
    const Point operator++(int) //후위증가
    {
        const Point retobj(xpos, ypos);   //후위증가는 연산 전 값을 보존해야하기 때문에 const로 선언
        xpos +=1;
        ypos +=1;
        return retobj;
    }
    friend Point& operator--(Point &ref);
    friend const Point operator--(Point &ref, int);
};

Point& operator--(Point &ref)   //전위감소
{
    ref.xpos-=1;
    ref.ypos-=1;
    return ref;
}

const Point operator--(Point &ref, int)   //후위감소
{
    const Point retobj(ref);    //후위감소는 연산 전 값을 보존해야하기 때문에 const로 선언
    ref.xpos-=1;
    ref.ypos-=1;
    return retobj;
}


int main(void)
{
    Point pos(3, 5);
    Point cpy;
    cpy = pos--;	//Point cpy = pos--;	
    /*
    Point cpy = pos--;
    Point cpy(pos--);
    Point cpy(const Point retobj); -> return값이 반환형이 const Point인 retobj 
    */
    cpy.ShowPosition();
    pos.ShowPosition();

    cpy=pos++;
    cpy.ShowPosition();
    pos.ShowPosition();
    return 0;
}

[3, 5]
[2, 4]
[2, 4]
[3, 5]

 

반환형에서의 const 선언과 const 객체

const Point operator--(Point &ref, int)   //후위감소
{
    const Point retobj(ref);    //후위감소는 연산 전 값을 보존해야하기 때문에 const로 선언
    ref.xpos-=1;
    ref.ypos-=1;
    return retobj;
}

• 해당 함수에서 retobj를 const 객체로 선언한 이유는 함수 내부에서 retobj의 값이 변하면 안 되기 때문이다.
• 반환형을 const 객체로 선언한 이유는 반환값인 retobj가 const 객체라서 그런 것이 아니다. 함수가 반환값을 return하는 과정에서 복사생성자가 호출되어 새로운 객체가 생성되기 때문에 retobj 객체의 const 선언유무는 retobj 객체의 반환에 아무런 영향을 끼치지 않는다.

 후위증가와 후위감수 함수의 반환형을 const 객체로 설정한 이유는 다음과 같은 연산을 막기 위해서라고 책에 서술되어있다.

(pos++)++;	//pos++의 반환형이 const Point이므로 compile error
(pos--)--;	//pos--의 반환형이 const Point이므로 compile error

 C++의 연산특성을 그대로 반영한 것으로, 전위연산은 ++(++pos), --(--pos)와 같은 연산이 가능하지만, 후위연산은 불가능하다.

 

 

+ 반환형을 const 객체로 설정한 이유는 pos의 복사본인 cpy를 선언할 때 복사생성자가 호출되고, 복사생성자의 매개변수로는 const 객체(복사의 대상이 되는 원본이 변하는 것은 좋지 않음)가 오는 것이 좋기 때문일까..? 생각해봤지만, 해당 예제에서 그렇게 하지 않는 경우가 훨씬 많다.

 

---

출처 : 윤성우, <윤성우의 열혈 C++ 프로그래밍>, 오렌지미디어, 2010.05.12