C++ 클래스 설계의 정석

생성자, 소멸자, 대입(=) 연산자

G. Bowden Wise 지음, 김 용묵 번역

여러분은 클래스를 직접 설계할 때, 속으로 여러 질문을 할 것입니다. 복사 생성자가 필요한가? 생성자 함수에 대체 인자(default arguments)가 필요한가? 클래스가 형변환이 되도록 만들 필요가 있는가? 같음 연산자를 정의할 필요가 있는가? 후위(postfix) 연산자는 어떻게 구현할까? 함수가 개체 자신을 되돌리게 할까, 개체의 참조자(reference)를 되돌리게 할까? 이 개체를 스트림으로는 어떤 식으로 내보낼까?

이런 질문은 노련한 C++ 프로그래머들도 곱씹고 고민하며, 때로는 이들조차 실수를 하여 비효율적인 코드를 작성하기도 합니다. 그래서 C++ 클래스를 결함 없이 설계하는 요령을 다룬 많은 책과 기사가 나갔습니다. 좀더 나은 C++ 프로그래머가 되려면 C++에서 있을 수 있는 미묘한 함정들을 배우고 이에 대한 안목을 키워야 할 것입니다.

이 다음부터 여러 회에 걸쳐, 나는 여러 C++전문가들의 지식과 약간의 내 경험에서 따온 C++ 활용 정석을 다루려고 합니다. 이 지침들이 여러분이 클래스를 스스로 구현하는 데 유용하게 쓰였으면 좋겠습니다. 이제 클래스의 특수한 함수부터 시작해 보겠습니다. 특수한 함수란 생성자, 소멸자, 대입 연산자 함수를 말합니다.

특수한 구성원 함수

클래스는 데이터와 함수를 모두 구성원으로 가집니다. 그리고 함수는 대개, 사용자가 개체를 대상으로 어떤 동작을 하게 해주는 중개 역할을 합니다. 그런데 함수 중에는 또다른 특별한 의미를 지닌 게 있습니다. 개체가 살아있는 동안 특별한 임무를 맡기 때문입니다. 클래스에서 특별한 구성원 함수 구실을 하는 것은 생성자, 소멸자, 대입 연산자 함수입니다.

개체의 생명 주기

개체는 인스턴스를 선언함으로써 프로그램 안에서 생겨납니다. 그밖에 컴파일러가 내부적인 목적으로 개체를 생성하는 코드를 집어넣기도 합니다. 개체를 선언할 때는 이름을 배당합니다. 이 이름을 가진 개체는 개체가 정의된 영역(scope) 안에서만 사용 가능합니다. 영역이란 코드가 들어있는 블록을 뜻하며, 개체는 그 영역 안에서만 사용 가능하게 됩니다.

영역에는 세 가지 범위가 있습니다. 중괄호 블록 안이 영역인 지역 범위가 있고, 소스 파일 안에 있는 모든 곳(블록 바깥 역시 포함)이 영역이 되는 파일 범위가 있으며, 클래스의 구성원으로 선언되어 모든 구성원 함수가 영역이 되는 클래스 범위가 있습니다. 파일 범위에 드는 변수는 전역 변수라고 일컬어집니다.

개체의 생명 주기는 저장 등급(storage class)에 의해 결정됩니다.

• 일반(Automatic).중괄호 안에서 선언된 개체는 일반 개체가 됩니다. 일반 개체는 프로그램 실행점이 변수가 선언된 곳을 지날 때마다 생겨나며, 실행점이 중괄호 구간을 벗어나면 소멸합니다.
• 고정(Static).개체 앞에 접두어static가 붙으면 이 개체는 고정 개체가 됩니다. 고정 개체는 한번 선언되면 프로그램이 실행돼 있는 동안 계속 그 값이 유지됩니다. 전역 개체도 역시 고정되어 있습니다. 고정 개체는 실행점이 이 개체를 선언하는 곳을 지날 때 딱 한번 생성되며, 처음 생성될 때 기본적으로 0으로 초기화됩니다.

C++은 개체가 쓰이기 전에 반드시 제대로 초기화가 될 수 있음을 언어 자체가 보증합니다. 개체는 생겨나는 때가 되면 그 개체에 딸린 메모리가 할당된 후 곧 초기화됩니다. C++언어는 개체를 초기화하는 일을 하는 특별한 함수를 제공하는데, 이것이 생성자 함수입니다.

생성자는 개체가 생겨날 때마다 호출됩니다. 개체는 지역 변수로 생길 수도 있고, 전역 변수로 생길 수도 있으며, new 연산자에 의해 생길 수도 있습니다. 생성자 함수를 명시적으로 호출해줄 수도 있고, 임시 개체가 생길 때도 개체가 생겨날 수 있습니다. 어떤 개체가 생성되면 그 개체의 일부인 개체들의 생성자도 제각기 호출됩니다.

이와 마찬가지로 개체가 생성 범위를 벗어나면 그 개체에 할당돼 있던 메모리는 사라지게 됩니다. C++언어는 개체가 소멸될 때 소멸자라고 하는 특수한 함수를 호출하여 소멸되는 개체가 고유한 마무리 작업--개체가 할당한 다른 메모리나 시스템 자원을 반환하는 일 같은--을 할 수 있게 해 줍니다.

C++은 특수한 역할을 맡는 또다른 특수한 함수를 제공합니다. 어떤 개체와 똑같은 복사본이 생겨야 할 때는 복사 생성자 함수가 호출됩니다. 그리고 개체이 어떤 값이 대입되면, 그 개체의 대입 연산자 함수가 호출되지요.

생성자

생성자 함수는 개체 자신에 할당된 메모리를 가공하여, 이것을 살아있는 개체가 저장된 메모리로 바꾸는 역할을 합니다. 생성자 함수에는 기본 생성자, 복사 생성자가 있으며, 그밖에도 여러 가지 인자를 받는 생성자가 있을 수 있습니다.

기본 생성자(Default constructor)

기본 생성자는 아무 인자도 받지 않는 생성자를 말합니다. 클래스 X에 대한 기본 생성자는 X::X()와 같은 형태를 취합니다. X::X(const int x=0)처럼 모든 인자에 대해 대체값을 가진 생성자 또한 기본 생성자가 됩니다. 아무 인자를 주지 않고도 호출할 수 있기 때문이지요.

기본 생성자는 개체가 생성자 함수에 아무런 인자를 주지 않아도 그 개체를 초기화해줍니다. 예를 들어 다음과 같은 선언은 문자열 s가 아무런 값이 없는 상태, 즉 빈 문자열로 초기화됨을 뜻하게 됩니다.

String s;

기본 생성자는 대개, 그 클래스의 형태를 띠면서 텅 빈 상태인 개체를 생성합니다. 예를 들어 복소수를 나타내는 클래스의 기본 생성자는 값이 0인 복소수를 만드는 역할을 하고, 연결리스트 클래스의 기본 생성자는 아무 내용이 없는 리스트가 되도록 자신을 초기화하지요.

정석 1.클래스에 기본 생성자를 만들어 두십시오. 그리고 대체 인자를 활용하여, 기본 생성자를 또 만드는 수고를 피하십시오.

클래스에서 생성자에 인자를 받도록 하는 경우가 자주 있습니다. 인자를 하나도 받지 않는 기본 생성자를 따로 만들기보다는, 대체 인자가 있는 생성자 함수를 만들어서 대체 인자가 기본 생성자 역할까지 하고, 대체 인자가 생성자 함수에 정보를 제공할 수 있게 하는 게 좋습니다. 이 기법은 코드를 더욱 간결하게 하고 코드의 재활용성을 높여줍니다.

예를 들어 클래스 String에 생성자가 String(), String(const char *str)과 같이 두 개가 있다면 이것을 String(const char *str=0)과 같이 하나로 줄일 수 있습니다.

기본 생성자는 하나밖에 없습니다. 그러므로 생성자 함수마다 모든 인자에 대체값을 집어넣지는 마십시오. 컴파일러가 대체 인자가 있는 생성자를 기본 생성자와 구분하지 못해 에러를 내게 됩니다.

기본 생성자를 가진 클래스를 만들기가 어려워 보일 때가 있습니다. 클래스가 만들어질 때 특정 구성원이 반드시 초기화되어야 그 클래스가 동작할 수 있는 경우 말입니다. 그렇지만 그 특정 자료를 나중에라도(이 개체가 생성되고 나서) 제공할 수 있는 방법을 열어놓는다면 그 클래스는 기본 생성자를 만들 수 있습니다. 예를 들어 여러분이 C++ 스트림 라이브러리를 써 봤다면, 출력 파일을 나타내는 개체를 파일 이름 없이 만들 수 있다는 사실을 알 것입니다.

ofstream out;

out.open("outfile");

템플릿을 만들 땐 조심하기 바랍니다. 코딩할 때 주의를 기울이지 않으면, 여러분의 템플릿은 기본 생성자가 없는 클래스는 받아들일 수 없게 될지도 모릅니다.

T element;

정석 2.적당한 곳이라면 어느 구성원 함수에든지 대체 인자를 넣으십시오.

대체 인자는 생성자 함수에만 쓸 수 있는 것은 아닙니다. 어느 구성원 함수에나 쓸 수 있으므로, 적당한 곳이라면 어디에나 대체 인자를 두십시오.

복사 생성자

복사 생성자는 개체를 복사할 때 호출되는 특별한 생성자입니다. 클래스 X의 복사 생성자는 X::X(const X&)라는 꼴을 가집니다. 아래와 같은 코드가 있을 때, s2는 s1이라는 개체를 자신으로 복사하는 복사 생성자를 호출함으로써 생성됩니다.

String s1("Hello, world!");   String s2 (s1);

복사 생성자는 우리가 모르게 컴파일러가 개체의 복사본이 필요할 때마다 자주 호출됩니다. 우리가 임시 개체라고 부르는 이러한 개체는 컴파일러가 필요할 때마다 생겨났다가 자기 임무를 다하면 소멸합니다. 이런 일이 가장 일반적으로 일어나는 때는 함수가 호출될 때입니다. 예를 들어 다음과 같이 String이라는 인자를 받는 함수가 있다고 칩시다.

void DisplayError (const String s);

정석 3.클래스의 복사 생성자를 항상 만들어 두고, 컴파일러가 대신 생성하도록 하지 마십시오. 특히 클래스에 포인터로 동적 메모리를 할당하는 구성원 변수가 있다면 반드시 복사 생성자를 만들어야 합니다.

만약 복사 생성자를 두지 않는다면 컴파일러는 클래스에 대해 기본 복사 생성자를 만듭니다. 기본 생성자 함수는 클래스의 각 구성원의 값을 단순히 복사해 오는 일만 합니다. 이런 동작은 포인터를 쓰지 않는 클래스에나 적합합니다. 클래스를 설계할 때마다 복사 생성자를 꼬박꼬박 만들어 두는 습관을 들이는 것이 좋습니다.

생성자 함수를 작성하는 요령

생성자 함수는 여러분이 개체를 직접 생성할 때 외에도 컴파일러가 임시 개체를 만들 때 등을 포함해도 자주 호출됩니다. 그렇기 때문에 생성자는 최대한 간결하고 효율적이어야 합니다. 다음은 생성자 함수를 만들 때 고려해 볼만한 정석입니다.

정석 4. 생성자 함수에서 구성원 변수를 초기화할 때는 대입 연산보다는 자체 초기화 방법을 쓰십시오. 이렇게 하면 코드의 효율이 높아지고 부가적인 생성자 함수 호출을 막을 수 있게 됩니다.

_center과 _color라는 구성원을 가진 Shape라는 클래스가 있습니다. 구성원의 자료형은 전자는 Point라는 클래스고 후자는 int입니다. 생성자 함수를 만들 때, 여러분은 대입 연산자를 써서 구성원을 초기화해야겠다는 생각을 언뜻 할 것입니다.

Shape::Shape (const Point center,  const int   color)

   {

      _center = center;

      _color  = color; 

    }

1. 구성원 변수는 클래스에 나열(선언)됐던 순서대로 초기화됩니다. 이를 '구성원 초기화'라고 합니다.
2. 본 클래스 자체의 생성자 함수가 호출됩니다.

파생(derive) 클래스의 경우 부모 클래스의 것부터 시작하여 위의 두 과정이 수행됩니다.

Shape 클래스의 생성자에서 _center는 1단계 동안에 생성되며, 이때 Point의 기본 생성자가 호출됩니다. 그리고 2단계로 들어가서 생성자 함수가 대입 연산자 함수를 호출하면 비로소 _center의 값이 바뀝니다.

_center는 자신을 담고 있는 클래스의 생성자 함수가 실행되기 전에--나중에 생성자 함수가 _center의 값을 어떻게 바꾸든지간에-- 언제나 먼저 초기화된다는 점을 알아두십시오. 하지만 Shape 생성자 함수의 초기화 목록을 쓰면, _center를 어떤 생성자 함수로 초기화할지를 조절할 수 있습니다.

Shape::Shape (const Pointer center,  const int color) 

     : _center(center)   , _color (color)   {   }

생성자를 만들 때, 구성원 데이터를 모두 이런 식으로 초기화하려고 하세요. 대개 이런 식으로 모두 초기화가 가능하기 때문에, 정작 생성자 함수의 몸체에는 아무 코드도 필요하지 않을 수도 있습니다. 이렇게 하면 코드는 더욱 읽기 쉽고 유지하기도 쉬워집니다.

사실 int형과 같은 내장된 자료형에는 생성자 함수가 없습니다. 그렇기 때문에 기본 자료형 변수는 대입문을 쓰든 구성원 초기화를 쓰든 차이는 없습니다. 하지만 모든 구성원 변수를 구성원 초기화라는 같은 방법으로 값을 할당하면 코드가 더욱 이해하거나 유지하기 쉬워집니다.

정석 5.구성원 변수들이 어떤 순서로 초기화되는지를 주의깊게 살피십시오. d2라는 변수를 초기화하기 위해 d1을 사용한다면 실제로 d1이 d2보다 먼저 초기화되는지 확인하십시오.

StringHandle이라는 클래스에서 구성원 변수가 다음과 같은 순서대로 선언되었다고 합시다.

String _str;   int    _handle;

다음과 같은 생성자는 정상적으로 컴파일되지만 실행중 에러를 발생시킬 것입니다.

StringHandle::StringHandle (const int h)

      : _handle (h),_str(QueryHandle(_handle))   {   }

_str이 클래스에서 먼저 나타났기 때문에 _str은 _handle보다 먼저 선언됩니다. 불행히도 _str은 생성 과정에서 생성되지 않은 _handle을 쓰게 되는 것입니다. 클래스에서 _handle을 _str 앞에 두면 이런 문제가 생기지 않습니다.

이 문제를 해결하려면 클래스 구성원 대신 생성자에 딸려 들어온 인자를 쓰면 됩니다.

StringHandle::StringHandle (const int h)

      : _handle(h),_str (QueryStringHandle(h))   {   }

초기화 목록에 있는 순서대로 초기화가 되지 않는 이유는 나중에 컴파일러가 개체들을 생성되었던 반대 순서로 소멸시킬 수 있게 하기 위해서입니다. 한 소스 파일에 클래스의 생성자와 소멸자 함수가 같이 있으리라는 보장은 없습니다. 그러나 두 함수 클래스 선언부는 같은 것을 참조하기 때문에 개체가 초기화된 순서를 알아내는 데는 모호함이 발생하지 않습니다.

정석 6.참조자 구성원과 const 개체는 생성자의 초기화 문법대로 초기화되어야 합니다.

연구실에서 구해낸 센서 자료를 관리하는 SensorData라는 클래스가 있습니다. 이 클래스는 여러 다른 센서 개체들과 더불어 자료 처리를 할 수 있기 때문에 생성자에서는 기존하는 센서의 참조자를 인자로 받습니다. 모든 센서에게 개방돼 있는 전역 데이터는 상수형 자료로 전달되지요.

참조자는 반드시 기존하는 개체를 가리키고 있어야 하기 때문에, 시작 부분에서 애초부터, 자료형이 같은 다른 개체를 가리키게끔 초기화되어야 합니다. 참조자는 일생 주기를 통틀어 대입 연산을 한 번만 할 수 있고, 상수형 개체도 초기화된 뒤부터는 값을 대입할 수 없습니다. 따라서 이 둘은 초기화 목록에서 초기화되어야 합니다. 다음은 SensorData의 생성자 함수로 가능한 모습입니다.

SensorData::SensorData (Sensor& aSensor const GlobalData data)

     : _rSensor(aSensor), _global (data)   {   }

정석 7.생성자 함수를 최대한 간결하게 만드십시오.  함수 오버헤드나 개체가 생성되는 과정에서 발생할 수 있는 에러를 줄여야 하기 때문입니다.

생성자는 개체가 생성될 때마다 호출됩니다. 여러분이 모르는 사이에 이런 일은 컴파일러가 임시 개체를 만들어낼 때를 포함해 대단히 자주 일어납니다. 개체를 초기화하는 데 긴 시간이 걸려서는 안됩니다. 개체 생성시에는 꼭 필요한 일만 하십시오. 생성 과정을 줄이면 에러의 발생 가능성도 줄어들게 됩니다.

정석 8. 상속받은 클래스라면, 생성자 안에서 부모 클래스의 생성자 함수를 반드시 호출하도록 하세요.

생성자 함수(소멸자와 대입 연산자 함수도 포함하여)는 상속이 되지 않습니다. 클래스에서 생성자 함수가 호출되기 전, 그러니까 클래스 구성원을 초기화할 때는, 구성원 하나하나에 대해서 그 클래스에 해당하는 생성자 함수가 호출되고 본 클래스의 기반 클래스의 생성자도 호출됩니다. 4번 정석에서 보았듯이, 컴파일러는 초기화 목록을 보고서 어떤 생성자 함수를 호출할 지 결정합니다. 만약 프로그래머가 파생 클래스 생성자의 초기화 목록에서 기반 클래스 생성자를 호출하지 않으면, 컴파일러는 기반 클래스의 기본 생성자를 호출하는 코드를 자동으로 삽입합니다. 하지만 만약 기반 클래스가 기본 생성자 함수를 갖추고 있지 않다면 컴파일러는 에러를 낼 것입니다.

파생 클래스의 초기화 목록에서는 구성원 변수와 기반 클래스를 초기화해 주는 습관을 들이는 것이 좋습니다. 나는 보통 파생 클래스 자신의 구성원을 초기화하기 전에 기반 클래스의 생성자를 먼저 호출하곤 합니다.

Shape라는 클래스로부터 Triangle이란 클래스를 파생한다고 합시다.

class Triangle : public Shape

 {

   public:

        Triangle (const Point center, 

                       const int color,

                       const Point v1,

                       const Point v2,

                       const Point v3);

   private:

        Point _v1, _v2, _v3;

   };

Triangle::Triangle (const Point center,

                             const int color,

                             const Point v1,

                             const Point v2,

                             const Point v3) 

    : Shape (center, color)   , _v1(v1), _v2(v2), _v3(v3)   {   }

소멸자

프로그램의 실행 위치가 어떤 개체의 생명 영역을 벗어나면 그 개체는 소멸하고, 그 개체가 차지하던 메모리는 해제됩니다. 개체가 소멸하기 직전에 그 개체의 소멸자 함수가 호출되며, 개체는 소멸자 함수 안에서 각종 마무리 작업을 할 수 있습니다. 클래스 X의 소멸자 함수는 X::~X()라는 꼴을 갖습니다.

정석 9.소멸자 함수는 이 개체가 생성됐던 순간뿐만 아니라 모든 시점에서 할당했던 모든 자원(메모리 등)을 해제해야 합니다.

메모리나 각종 자원의 할당은 개체가 생성되는 첫 시점에서 행해지는 게 보통입니다. 그러나 때에 따라서는, 그 개체로 어떤 동작이 가해지면 개체가 거기에 반응하는 과정에서 자원이 추가로 쓰일 수도 있습니다. 소멸자 함수를 코딩할 때는, 비단 생산될 때뿐만 아니라 이 개체가 살아 생전에 사용한 모든 자원을 반환· 해제하도록 하십시오.

정석 10.클래스에 반드시 소멸자를 갖추십시오. 컴파일러로 하여금 소멸자를 알아서 만들도록 하지 마십시오.

클래스가 동작하는 모습을 완전히 파악하고 있는 게 좋습니다. 컴파일러가 어떤 코드도 임의로 만들게 하지 마세요.

정석 11.만약 어떤 클래스가 상속 받아 상속받는 클래스의 기반 클래스로 쓰일 여지가 있다면 소멸자 함수를 가상 함수로 만드십시오. 또한 클래스에 가상 함수가 적어도 하나 이상 있다면 소멸자 함수 역시 가상 함수로 만들어야 합니다.

자동차 클래스에 대한 상속 관계를 생각해 봅시다. 상속 관계에 있는 모든 클래스가 Auto라는 클래스에서 상속을 받았습니다. Ford라는 개체가 다음과 같이 생성되었다면 생성자 함수는

Ford f;

Auto* car1 = new Ford;   // ...   delete car1;

생성자와 소멸자를 작성하는 요령

다음은 생성자와 소멸자 함수 작성에 대해 적용할 수 있는 몇 가지 정석입니다.

정석 12.생성자와 소멸자 함수에서 가상함수를 호출하는 일을 삼가십시오.

생성자나 소멸자 함수 안에서도 다른 함수를 호출할 수 있습니다. 그런데 여기서 가상함수를 호출하면, 자신의 기반 클래스에서 정의된 가상함수, 혹은 자신이 새로 추가한 가상 함수는 적절히 호출되지만, 자신으로부터 상속한 새로운 파생 클래스가 새로 오버라이딩한 가상 함수는 절대 호출되지 않습니다. 이는 개체의 생성 과정에서, 아직 생성되지 않은 파생 클래스 개체를 기반 클래스가 건드리지 않기 위해서입니다. (기반 클래스의 생성자가 파생 클래스의 생성자보다 먼저 호출되지요.)

그리고 생성되거나 파괴되고 있는 개체의 순수 가상 함수를 직접 혹은 간접적으로 호출했을 때의 결과는 정해져 있지 않습니다. 올바른 결과가 나올 때란, 순수 가상 함수라도 특정 클래스의 것을 명시적으로 호출했을 때 뿐입니다. 예를 들어 A라는 클래스에 순수 가상 함수 p()가 있을 때, A::p()는 명시적인 호출이라 할 수 있습니다. 이 방식이 통하는 이유는, 명시적 호출은 가상함수 호출 메카니즘을 쓰지 않기 때문이지요.

대입 연산자

개체에 대입 연산을 시도하면 그 클래스의 대입 연산자가 호출됩니다. 클래스 X에 대한 대입 연산자는 다음 두 가지 형태 중 하나가 됩니다.

X& X::operator= (const X& x);   const X& X::operator= (const X& x);

정석 13.대입 연산자는 반드시 구성원 함수여야 하며, 친구(friend)가 될 수 없습니다.

어떤 연산자는 구성원 함수로 표현되는게 가장 좋고, 또 어떤 건 친구 함수로 표현되는 게 가장 좋습니다. 하지만 대입 연산자 함수는 선택의 여지가 없이 구성원 함수여야 합니다. 형태는 위의 두 가지 꼴 중 하나가 될 수 있죠.

정석 14.대입을 받은 개체의 참조자를 되돌림값으로 주도록 하세요.

참조자란 실제로 존재하는 개체를 비춰 보이는 거울과 같습니다. 참조자에 어떤 동작이 행해지면 참조자가 가리키는 실제 개체 역시 영향을 받습니다. 참조자란 간단히 말해 개체의 또다른 이름(별명)이라는 사실을 떠올리세요. (예를 들어 printf("%p %p \n",&,&)는 0xbffff870 0xbffff870를 출력합니다.).

참조자를 되돌리는 게 좋은 이유는 다음과 같습니다.

1. (void형 되돌림값과 비교해서) 아래와 같이 여러 대입문이 연결될 수 있게 해 주기 때문입니다.

   Complex w, x, y, z;   w = x = y = z = Complex(0,0);

2. (개체 자신을 되돌리는 것과 비교해서) 개체의 복사본을 또 생성하고 소멸하는 것보다 단순히 참조자만을 되돌리는 게 효율적이기 때문입니다.

대입이 연달아 되게 하기 위해서는 대입 연산자 함수의 인자와 되돌림의 자료형이 모두 같아야 합니다. 그래서 자료형이 같은 참조자를 되돌리고 전달하는 것입니다. 보통 return *this; 라고 하지요. 이렇게 하면 대입 연산의 결과가 다음 대입 연산 함수의 인자로 쓰일 수 있게 됩니다.

참조자를 되돌리는 것은 개체 자신을 직접 되돌리는 것보다 효율적입니다. 참조자가 넘겨지면 기본적인 함수 호출 방식인 "값으로 호출" (call-by-value) 메카니즘은 무시됩니다. 인자의 복사본을 받는 대신 함수는 실제 인자의 l-value를 받게 됩니다. 아무 개체도 복사되지 않으며, 참조자는 개체 전체보다 스택도 적게 차지합니다. 이와 마찬가지로 참조자가 되돌려졌을 때에도 개체 자체가 아닌 l-value가 되돌려집니다.

정석 15. 반드시 함수의 참조자는 상수형(const)으로 해서 되돌리십시오. 일반 참조자를 되돌리면 엉뚱한 결과가 생길 수 있습니다.

참조자를 되돌리는 것은 l-value(값을 대입할 수 있는 메모리 주소를 갖는 개체)를 되돌리는 것과 같습니다. 이것은 개체에 대한 포인터를 얻는 것과 비슷합니다. 그러므로 개체 참조자를 통해 개체를 변경할 수 있는 것입니다.

여기에 예를 들어 보겠습니다. 대입 연산은 오른쪽에서 왼쪽으로 진행되지만 아래에서는 괄호를 써서 우선 순위를 바꿨습니다.

Complex x, y, z;   (x = y) = z;

(x.operator=(y)).operator=(z);

다만, 상수형이 아닌 일반 참조자를 되돌려야 하는 경우가 딱 하나 있습니다. 첨자 연산자는 일반 참조자를 되돌려야 색인 번호가 매겨진 개체에 다른 값을 대입할 수 있기 때문입니다. 벡터의 좌표를 바꾸는 코드를 작성하고 싶다고 가정해 봅시다.

Vector v;   v[1] = -2.0;

(v.operator[](1)).operator= (-2.0);

float& Vector::operator[] (const int)   {      return _data[i];   }

정석 16.자기를 자기 자신에게 대입하지는 않는지 검사하십시오.

개체가 자기 자신으로 대입될 경우 불미스런 일이 생길 수 있습니다.

X x;   x = x;

자기 자신으로 대입하는 게 아닌지 아래 예처럼 꼭 검사하십시오.

const X& X::operator= (const X& rhs)

   {

      if ( &rhs != this )

      {         //각 구성원에 값을 할당합니다.      }

      return *this;

   }

정석 17.대입연산자는 상속 받지 않는 유일한 연산자입니다. 기반 클래스의 구성원도 할당 과정에서 값을 바꾸도록 하십시오.

파생 클래스의 대입 연산자 함수는 자기가 갖고 있는 구성원 뿐만 아니라 기반 클래스의 구성원까지 반드시 고쳐야 합니다. 그런데 기반 클래스의 구성원이 private로 선언돼 있어서 파생 클래스에서 그걸 건드릴 수 없는 경우가 있습니다. 그럴 때는 기반 클래스의 대입 연산자 함수를 파생 클래스의 대입 연산자 함수에서 직접 호출해야 합니다.

Base라는 클래스가 Derived의 기반 클래스라고 칩시다. Derived형 개체에 대입이 일어나면, Base 클래스도 이 때 대입 연산이 행해져야 클래스 전체의 내용이 바뀝니다. 그래서 Derived 클래스의 대입 연산자 함수는 아래와 같이, 기반 클래스의 대입 연산자를 직접 호출할 수도 있고, (d가 피연산자라고 합시다.)

Base::operator= (d);

((Base &) *this) = d;

정석 18.클래스에 자체적인 대입 연산자 함수를 꼭 만들어 두십시오. 컴파일러가 기본 함수를 만들도록 하지 마세요.

프로그래머가 대입 연산자 함수를 만들지 않으면 컴파일러는 기본 함수(모든 구성원을 똑같이 대입하는 일만 함)를 알아서 만듭니다. 여러분의 클래스가 어떻게 돌아가는지 완전히 파악하고 있기 위해서는 항상 대입 연산자 함수를 만들도록 하십시오.

정석 19.클래스에 포인터 데이터(동적 메모리 할당)가 있으면 대입 연산자를꼭만들어야 합니다. 그리고 대입 연산자를 코딩한다면 복사 생성자도 만들어야 합니다.

컴파일러가 기본적으로 만든 대입 연산자 함수는 각 구성원을 차례대로 복사하는 작업만 합니다. 그러므로 구성원 중에 포인터가 있다면 이를 그대로 둬서는 안되는 경우가 절대 다수입니다. 두 개 이상의 개체가 똑같이 한 메모리 영역을 가리키고 있는데, 한 개체가 그 메모리 영역을 해제한다면, 다른 개체가 그 메모리를 건드릴 때 런타임 에러가 나겠지요.

정석 20.대입 연산자와 복사 생성자가 공통적으로 수행하는 작업을 따로 함수로 만들어 이들이 그 함수를 호출하게 하십시오. 이렇게 하면 코드의 중복이 사라져 보기가 더 깔끔해집니다.

문자열 클래스는 복사 생성이나 대입 연산 과정에서 문자열을 복사한다는 공통된 작업을 해야 합니다. 그래서 겹치는 작업을 다음과 같이 비공개 구성원 함수에다 두면 복사 생성자 함수와 대입 연산자 함수가 그 코드를 중복 없이 공유할 수 있을 것입니다.

void CopyString(const char* ptr);

다음에 우리는 클래스에서 연산자 함수를 구현하는 데에 도움이 되는 내용을 살펴볼 것입니다. 독자 여러분은 그때까지, 자신이 이미 만들어놓은 클래스를 살펴 보시기 바랍니다. 그리고는 생성자, 소멸자, 대입 연산자 함수가 잘 동작하고 있는지 살펴보세요. 여기 실린 정석은 여러분이 더 효율적인 코드를 작성하는 데 도움이 될 것입니다.

참고 자료

1

COPLIEN, J. O.Advanced C++ Programming Styles and Idioms. Addison-Wesley, Reading, Mass., 1992.

2

ELLIS, M. A., AND STROUSTRUP, B.The Annotated C++ Reference Manual. Addison-Wesley, Reading, Mass., 1990.

3

Journal of Object-Oriented Programming. SIGS Publications, New York.

4

MURRAY, R. B.C++ Strategies and Tactics. Addison-Wesley, Reading, Mass., 1993.

5

MYERS, S.Effective C++. Addison-Wesley, Reading, Mass., 1992.

저작권 1995G. Bowden Wise 지음

C++에 대해 더 자세히 알고 싶다면, 본 시리즈의차례,다음 내용,이전 내용을 살펴보십시오.

고치고 더함: 2000년 2월 4일 금요일, 11:17:16
이 사이트의 원위치: www.acm.org/crossroads/xrds1-4/ovp.html

ⓒ 저작권 2000, ACM, Inc.