C++ Chapter 11-2 : 배열의 인덱스 연산자 오버로딩

배열 클래스

 C와 C++의 기본 배열은 경계검사를 하지 않는다. 따라서, 다음과 같은 범위를 벗어나는 코드가 컴파일, 실행이 무리없이 진행되는 문제가 생긴다.

int main(void)
{
    int arr[3]={1, 2, 3};
    cout<<arr[-1]<<endl;    //'arr의 주소 + sizeof(int) X -1'의 위치에 접근
    cout<<arr[-2]<<endl;    //'arr의 주소 + sizeof(int) X -2'의 위치에 접근
    cout<<arr[3]<<endl;
    cout<<arr[4]<<endl;
    . . . . .
}

멤버함수 연산자 오버로딩을 통해서 이런 특성을 배제하고 사용할 수 있게 바꿔보자.

#include <iostream>
#include <cstdlib>
using namespace std;

class BoundCheckIntArray
{
private:
    int * arr;
    int arrlen;
public:
    BoundCheckIntArray(int len) : arrlen(len)
    {
        arr = new int[len];
    }
    int& operator[] (int idx)   //배열 요소의 참조값을 반환하여 연속 접근 가능하게 만듦
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    ~BoundCheckIntArray()
    {
        delete []arr;
    }
};

int main(void)
{
    BoundCheckIntArray arr(5);
    for(int i = 0; i<5; i++)
        arr[i] = (i+1)*11;
    for (int i = 0; i<6; i++)   //반복의 범위를 1 넘치게 설정
        cout<<arr[i]<<endl;

    return 0;
}

11
22
33
44
55
Array index out of bound exception

• 이처럼 [] 연산자 오버로딩을 통해 배열 접근의 안정성을 보장받을 수 있다.

 다음과 같은 상황을 막고자 더욱 안정성을 높이려면,

int main(void)
{
    BoundCheckIntArray arr(5);
    for(int i = 0; i<5; i++)
        arr[i] = (i+1)*11;
	BoundCheckIntArray cpy1(5);
    cpy1=arr;	//안전하지 않은 코드
    BoundCheckIntArray copy = arr;	//안전하지 않은 코드
    return 0;
}

배열은 저장소의 일종이고, 저장소에 저장된 데이터가 양질의 데이터가 되기 위해서는 '유일성'을 보장받아야 한다(똑같은 주민등록번호가 둘 존재한다면 주민등록번호를 통한 본인 확인은 의미가 없어짐). 따라서, 이렇게 복사 생성자와 대입 연산자를 private으로 선언해서, 복사 또는 대입을 원천적으로 막을 수도 있다.

class BoundCheckIntArray
{
private:
    int * arr;
    int arrlen;
    BoundCheckIntArray(const BoundCheckIntArray& arr) { }
    BoundCheckIntArray& operator=(const BoundCheckIntArray& arr) { }
public:
	. . . .
}

 

const 함수를 이용한 오버로딩의 활용

 앞서 정의한 BoundCheckIntArray 클래스에는 제약이 존재하는데, 예제를 통해 확인하자.

#include <iostream>
#include <cstdlib>
using namespace std;

class BoundCheckIntArray
{
private:
    int * arr;
    int arrlen;
    BoundCheckIntArray(const BoundCheckIntArray& arr) { }
    BoundCheckIntArray& operator=(const BoundCheckIntArray& arr) { }
public:
    BoundCheckIntArray(int len) : arrlen(len)
    {
        arr = new int[len];
    }
    int& operator[] (int idx) 
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    int GetArrayLen() const { return arrlen; }
    ~BoundCheckIntArray()
    { delete []arr; }
};

void ShowAllData(const BoundCheckIntArray& ref)
{
    int len=ref.GetArrayLen();
    for(int idx=0; idx<len; idx++)
        cout<<ref[idx]<<endl;
}

int main(void)
{
    BoundCheckIntArray arr(5);
    for(int i = 0; i<5; i++)
        arr[i] = (i+1)*11;
    
    ShowAllData(arr);

    return 0;
}

 

• ShowAllData의 매개변수는 const 객체 참조자인 ref이다.
• ref[idx]는 ref.operator[](idx)로 해석된다
• operator[]는 const 선언되지 않은 함수이므로, const 객체인 ref에서 호출될 수 없다.
• 그렇다고 operator[]에 const선언을 해버리면, 데이터를 저장하는 배열의 특성을 잃는다. 

 const 선언의 유무도 함수 오버로딩의 조건 중 하나이며, 이를 이용해서 문제를 해결할 수 있다.

#include <iostream>
#include <cstdlib>
using namespace std;

class BoundCheckIntArray
{
private:
    int * arr;
    int arrlen;
    BoundCheckIntArray(const BoundCheckIntArray& arr) { }
    BoundCheckIntArray& operator=(const BoundCheckIntArray& arr) { }
public:
    BoundCheckIntArray(int len) : arrlen(len)
    {
        arr = new int[len];
    }
    int& operator[] (int idx) 
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    int operator[] (int idx) const
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    int GetArrayLen() const { return arrlen; }
    ~BoundCheckIntArray()
    { delete []arr; }
};

void ShowAllData(const BoundCheckIntArray& ref)
{
    int len=ref.GetArrayLen();
    for(int idx=0; idx<len; idx++)
        cout<<ref[idx]<<endl;	//const 객체이므로 const 선언된 operator[] 호출
}

int main(void)
{
    BoundCheckIntArray arr(5);
    for(int i = 0; i<5; i++)
        arr[i] = (i+1)*11;	//const 선언되지 않은 객체이므로 const 함수가 아닌 operator[] 호출
    ShowAllData(arr);

    return 0;
}

11
22
33
44
55

 

객체 저장을 위한 배열 클래스의 정의

 지금까지 기본자료형 대상의 배열 클래스를 배웠으니, 이번에는 객체를 대상으로 배열 클래스를 정의해보자.

class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y) { }
    friend ostream& operator<<(ostream& os, const Point& pos);
};

ostream& operator<<(ostream& os, const Point& pos)
{
    os<<'['<<pos.xpos<<", "<<pos.ypos<<']'<<endl;
    return os;
}

 대상이 되는 객체의 클래스는 위와 같다.

 

 먼저 객체 자체를 저장하는 배열 클래스 예제이다.

#include <iostream>
#include <cstdlib>
using namespace std;

class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y) { }
    friend ostream& operator<<(ostream& os, const Point& pos);
};

ostream& operator<<(ostream& os, const Point& pos)
{
    os<<'['<<pos.xpos<<", "<<pos.ypos<<']'<<endl;
    return os;
}

class BoundCheckPointArray
{
private:
    Point * arr;
    int arrlen;

    BoundCheckPointArray(const BoundCheckPointArray& arr) { }
    BoundCheckPointArray& operator=(const BoundCheckPointArray& arr) { }

public:
    BoundCheckPointArray(int len) : arrlen(len)
    {
        arr = new Point[len];
    }
    Point& operator[] (int idx) 
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    Point operator[] (int idx) const
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    int GetArrayLen() const { return arrlen; }
    ~BoundCheckPointArray()
    { delete []arr; }
};

int main(void)
{
    BoundCheckPointArray arr(3);
    arr[0] = Point(3, 4);
    arr[1] = Point(5, 6);
    arr[2] = Point(7, 8);
    
    for(int i=0; i<arr.GetArrayLen(); i++)
        cout<<arr[i];
    
    return 0;
}

[3, 4]
[5, 6]
[7, 8]

 다음은 객체의 주소를 저장하는 배열 클래스 예제이다.

#include <iostream>
#include <cstdlib>
using namespace std;

class Point
{
private:
    int xpos, ypos;
public:
    Point(int x=0, int y=0) : xpos(x), ypos(y) { }
    friend ostream& operator<<(ostream& os, const Point& pos);
};

ostream& operator<<(ostream& os, const Point& pos)
{
    os<<'['<<pos.xpos<<", "<<pos.ypos<<']'<<endl;
    return os;
}

typedef Point * POINT_PTR;  //Point 포인터 형을 의미하는 POINT_PTR 정의

class BoundCheckPointPtrArray
{
private:
    POINT_PTR * arr;
    int arrlen;

    BoundCheckPointPtrArray(const BoundCheckPointPtrArray& arr) { }
    BoundCheckPointPtrArray& operator=(const BoundCheckPointPtrArray& arr) { }

public:
    BoundCheckPointPtrArray(int len) : arrlen(len)
    {
        arr = new POINT_PTR[len];   //저장의 대상이 포인터 객체의 주소이므로 POINT_PTR 배열 생성
    }
    POINT_PTR& operator[] (int idx) 
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    POINT_PTR operator[] (int idx) const
    {
        if(idx<0 || idx>=arrlen)
        {
            cout<<"Array index out of bound exception"<<endl;
            exit(1);
        }
        return arr[idx];
    }
    int GetArrayLen() const { return arrlen; }
    ~BoundCheckPointPtrArray() { delete []arr; }
};

int main(void)
{
    BoundCheckPointPtrArray arr(3);
    arr[0] = new Point(3, 4);
    arr[1] = new Point(5, 6);
    arr[2] = new Point(7, 8);
    
    for(int i=0; i<arr.GetArrayLen(); i++)
        cout<<*(arr[i]);

    delete arr[0];
    delete arr[1];
    delete arr[2];
    
    return 0;
}

[3, 4]
[5, 6]
[7, 8]

 객체의 주소를 저장하기 때문에 깊은 복사인지 얕은 복사인지 신경쓰지 않아도 된다. 

 

---

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