15-1-나.포인터와 const

const를 포인터와 함께 사용하면 효과가 조금 달라진다. 다음 예제는 포인터와 const의 관계를 실험해 보기 위해 작성했는데 컴파일해 보면 몇 군데서 에러가 발생할 것이다.

예 제 : ConstPointer

#include <Turboc.h>

void main()

{

int ar[5]={1,2,3,4,5};

int *pi1=&ar[0];

pi1++; // 포인터가 다른 대상체를 가리킬 수 있다.

*pi1=0; // 대상체를 변경할 수 있다.

const int *pi2=&ar[0];

pi2++; // 포인터가 다른 대상체를 가리킬 수 있다.

*pi2=0; // 에러 : 대상체가 상수이므로 변경할 수 없다.

int * const pi3=&ar[0];

pi3++; // 에러 : 포인터가 다른 대상체를 가리킬 수 없다.

*pi3=0; // 대상체는 변경할 수 있다.

const int * const pi4=&ar[0];

pi4++; // 에러 : 포인터가 다른 대상체를 가리킬 수 없다.

*pi4=0; // 에러 : 대상체가 상수이므로 변경할 수 없다.

}

정수형 배열 ar이 선언되어 있고 이 배열을 가리키는 포인터 4개를 선언하는데 const의 위치에 따라 상수가 되는 대상이 조금씩 달라진다. 먼저 const를 쓰지 않은 일반적인 포인터 pi1을 보자. pi1은 ar[0]의 번지, 그러니까 ar 배열의 첫 번째 요소를 가리키고 있다. 이 상태에서 pi1을 증가시키면 배열의 다른 요소를 가리키도록 이동하며 *pi1연산식으로 pi1이 가리키는 곳의 값을 읽거나 바꿀 수 있다. pi1 포인터 자체도 상수가 아니며 pi1이 가리키는 대상체도 상수가 아니므로 양쪽 모두 원하는대로 변경 가능하다.

다음은 const int * 타입으로 선언된 pi2를 보자. 이 포인터는 const int를 가리키는 포인터 변수로 선언되었으므로 이 포인터가 가리키는 대상체는 정수형 상수이며 포인터 자체는 상수가 아니다. 그래서 pi2++이나 pi2-- 또는 pi2에 다른 대상체의 번지를 직접 대입하여 pi2가 다른 대상체를 가리키도록 할 수는 있지만 *pi2를 변경하는 것은 허락되지 않는다. 상수만 가리키는 포인터로 선언되었기 때문에 이 포인터가 가리키는 곳의 내용을 변경할 수 없다. 이런 포인터를 상수 지시 포인터(Pointer to Constant)라고 한다.

물론 pi2가 가리키고 있는 ar 배열 자체는 상수가 아니므로 ar[0]=0;와 같이 직접 이 배열 요소에 값을 대입하는 것은 가능하다. 하지만 pi2 포인터로 간접적으로 배열 요소의 값을 변경할 수는 없다. 상수 지시 포인터가 가리키는 곳의 내용은 상수로 취급되므로 이 포인터를 사용하여 값을 바꾸는 것은 에러로 처리된다.

다음은 const 예약어가 포인터 변수 앞에 사용된 pi3를 보자. int * const pi3로 선언되어 있는데 이 선언문은 pi3 포인터 변수를 상수로 만든다. 이런 포인터를 상수 포인터(Constant Pointer)라고 하며 변수 자체가 상수이므로 다른 대상체를 가리킬 수 없지만 이 포인터가 가리키는 대상체는 상수가 아니므로 대상체의 값을 변경하는 것은 가능하다.

마지막 4번째 예 pi4는 const가 대상체와 포인터 변수에 모두 사용되었는데 이렇게 선언하면 포인터 변수 자체도 상수이고 대상체도 상수로 취급된다. 이름을 붙이자면 상수 지시 상수 포인터라고 할 수 있다. 그래서 pi4는 최초 선언될 때 주어진 ar[0] 이외의 다른 대상체를 가리킬 수 없으며 ar[0]의 값을 변경할 수도 없다. 오로지 ar[0]의 값을 읽을 수만 있다.

포인터 선언시 const 키워드로 상수 포인터를 만드는 4가지 경우를 살펴 봤는데 조금 혼란스러울 것이다. const 키워드의 위치에 따라 상수가 되는 대상이 달라지는데 pi2와 pi3의 경우만 잘 구분하면 된다. const 키워드 바로 다음 대상이 상수가 되는데 타입 앞에 있으면 대상체가 상수가 되며 변수명 앞에 있으면 변수만 상수가 된다.

int const *는 const int *와 같은 표현이며 대상체가 상수인데 const의 위치가 직관적이지 않아서 잘 사용되지 않는다. 다음은 한단계 더 확장해서 이중 포인터와 const의 관계에 대해 연구해 보자. 이중 포인터의 경우는 const int * const * const ppi; 따위로 const를 세 군데나 붙일 수 있고 위치에 따라 const의 의미는 달라진다.

■ 제일 앞 : ppi가 가리키는 포인터가 가리키는 정수가 상수라는 뜻

■ 가운데 : ppi가 가리키는 포인터가 상수라는 뜻

■ 제일 끝 : ppi 자체가 상수 포인터라는 뜻

다음 예제는 const의 위치에 따라 이중 포인터가 어떤 의미를 가지며 어떤 동작이 금지되는지를 테스트한다. 에러가 나는 문장은 모두 주석 처리해 두었으며 뒤쪽에 설명을 달아 두었으므로 주석을 읽어 보도록 하자.

예 제 : ConstDblPointer

#include <Turboc.h>

void main()

{

int i=5;

int *pi=&i;

const int *pci;

int * const cpi=&i;

const int * const cpci=&i;

// 일반 이중 포인터 - 모두 가능

int **ppi1=&pi;

ppi1++;

(*ppi1)++;

**ppi1=0;

// 상수 지시 포인터의 포인터

const int **ppi2=&pci;

ppi2++;

(*ppi2)++;

// **ppi2=0; // 에러 : 최종 대상체(정수) 변경 불가

// 비상수 지시 상수 포인터의 포인터

int * const *ppi3=&cpi;

ppi3++;

// (*ppi3)++; // 에러 : 중간 대상체(포인터) 변경 불가

**ppi3=0;

// 비상수 지시 비상수 포인터의 상수 포인터

int ** const ppi4=&pi;

// ppi4++; // 에러 : 포인터 자체 변경 불가

(*ppi4)++;

**ppi4=0;

// 상수 지시 상수 포인터를 지시하는 상수 포인터 - 전부 에러

const int * const * const ppi5=&cpci;

// ppi5++;

// (*ppi5)++;

// **ppi5=0;

}

이 예제를 보고 아마 여러분들은 "아니 이 사람이 지금 장난하나?" 이런 생각을 할 것이다. 장난 하는 게 맞다. 실전에서 이런 포인터가 꼭 필요한 경우는 그리 흔하지 않으므로 이런 복잡한 것까지 상세하게 알아야 할 필요는 없지만 이 정도 연습이 되어 있다면 포인터와 const의 관계를 확실하게 안다고 자부해도 좋다. const 바로 다음 대상이 상수가 된다는 원칙은 동일하다. 이중 포인터에 대해 const 키워드를 쓰는 경우는 사실상 무척 드물지만 포인터의 레퍼런스에 대해서는 종종 이런 표현이 사용되기도 한다.

그렇다면 왜 상수 포인터가 필요한 것일까? const int *pi2의 대상체가 상수라는 것을 알고 있다면 *pi2의 값을 바꾸지 않으면 그만이 아닌가? 컴파일러 차원에서 이런 상수 포인터를 지원하는 이유는 고의든 실수든 바뀌지 말아야 할 중요한 값을 보호하기 위해서이다. 다음 코드에서 RATIO는 어떤 계산식에 사용되는 아주 중요한 상수이다.

const double RATIO=82.34;

RATIO=99.99; // 에러

const double *pd=&RATIO;

*pd=99.99; // 에러

상수로 선언했으므로 두 번째 줄처럼 RATIO에 어떤 값을 직접 대입하는 것은 당연히 에러로 처리될 것이다. 눈에 뻔히 보이는 상수에 값을 대입하는 멍청한 실수를 하지는 않지만 포인터를 통해 간접적으로 이 값을 액세스할 때는 우발적인 실수를 할 가능성이 있다. RATIO는 상수라서 좌변값이 아니지만 메모리를 점유하고 있고 번지가 있으므로 &연산자의 피연산자로 사용될 수 있다.

만약 이 상수를 가리키는 포인터 pd를 사용하여 간접적으로 RATIO의 값을 바꿀 수 있다면 이것은 잠재적으로 논리적인 에러가 될 위험이 아주 크다. 상수를 가리키는 포인터를 함수끼리 주거니 받거니 하다 보면 언제 이 값이 바뀌어 버릴지 알 수 없어진다. 만약 RATIO가 직원들에게 줄 보너스 비율이라면 이 값이 조금만 커져도 엄청난 재정 누출이 발생할 것이다. 이렇게 되면 직원들은 좋아하겠지만 버그를 만든 개발자는 사표를 써야 할 것이다.

포인터는 대상체를 옮겨 다니며 값을 읽기도 하고 바꿀 수도 있는 굉장히 편리한 도구이지만 다소 위험한 면이 있다. 어떤 대상체에 대한 번지를 알고 있으면 포인터를 통해 이 대상체를 마음대로 바꿀 수 있기 때문이다. 일부러 그렇게 하지는 않겠지만 실수로 포인터를 잘못 조작하거나 또는 외부적인 다른 에러에 의해 포인터가 엉뚱한 곳을 가리킬 가능성은 항상 있다.

짧은 코드에서는 이런 실수를 하더라도 금방 어디서 문제가 발생했는지 발견할 수 있지만 대형 프로젝트에서는 실수를 한 곳과 증상이 나타나는 곳이 완전히 딴 곳일 수 있기 때문에 발견하기 대단히 어렵다. 게다가 대형 프로젝트는 보통 여러 개발자가 동시에 작업을 하는데 좀 띨띨한 개발자가 이런 실수를 하면 프로젝트 전체가 시한폭탄을 가지게 되는 셈이다. 그래서 컴파일러 차원에서 포인터를 좀 더 안전하게 쓸 수 있는 장치를 제공할 필요가 있는데 그것이 바로 const이다.

중형급 승용차의 문짝에는 안에서 문을 열지 못하도록 밖에서 잠그는 장치가 있는데 이 장치는 주로 아동들을 보호하기 위해 존재한다. 아이들이 주행중에 차문을 열어서 밖으로 떨어지면 돌이킬 수 없는 사고가 발생할 수 있기 때문에 출발전에 밖에서 문을 잠글 수 있다. 물론 아빠가 출발전에 "달리는 중에 절대 문을 열어서는 안되"하고 주의를 줄 수도 있지만 장난꾸러기들에게는 이런 말이 오히려 더 위험할 수도 있다. 이 장치는 아이들의 자유를 구속하기 위한 것이 아니라 혹시라도 있을지 모르는 실수나 무모한 호기심으로부터 소중한 아이들의 생명을 지키기 위한 것이다. const는 컴파일러가 미숙련 개발자를 위해 제공하는 일종의 안전 장치라고 할 수 있다.

const는 읽기만 가능한 읽기 전용 포인터를 정의할 수 있도록 함으로써 포인터를 잘못 조작하는 실수를 컴파일러가 발견할 수 있도록 한다. 구조체를 함수의 인수로 넘길 때는 값으로 넘기는 것보다 포인터로 넘기는 것이 훨씬 더 효율적인데 이렇게 하면 참조 호출이므로 함수 내부에서 실인수를 변경할 수 있어 위험해진다. 이것을 금지하고 싶을 때 읽기 전용의 상수 지시 포인터로 전달한다. 4바이트만 전달되므로 속도가 빠르고 함수가 실인수를 읽을 수만 있으므로 안전하다. 13장의 OutFriend 함수는 const tag_Friend *pf를 받는 것이 가장 이상적이다. 컴파일러는 const 포인터의 안전성을 높이기 위해 const 포인터와 일반 포인터끼리의 대입에 대해 엄격한 규칙을 적용한다. 다음 예제를 보자.

예 제 : ConstAssign

#include <Turboc.h>

void main()

{

int ar[5]={1,2,3,4,5};

int *pi1=&ar[0];

const int *pi2;

pi2=pi1; // 가능

pi1=pi2; // 불가능

pi1=(int *)pi2; // 가능하지만 바람직하지 않다.

}

pi1은 일반 포인터이며 ar[0]를 가리키도록 초기화되었고 pi2는 상수 지시 포인터이다. 이 상태에서 pi2가 pi1의 번지를 대입받는 것은 가능하다. 상수 지시 포인터로는 대상체를 읽을 수만 있기 때문에 읽기 쓰기가 모두 가능한 pi1 대상체의 번지를 대입받아도 아무 문제가 없다.

그러나 그 반대는 허가되지 않는데 일반 포인터 pi1이 상수 지시 포인터 pi2의 번지를 대입받을 수는 없다. 만약 이것이 허가된다면 pi2가 가리키는 상수 대상체를 pi1을 통해 간접적으로 변경하는 것이 가능해지며 이렇게 되면 상수 지시 포인터를 지원하는 의미가 없어진다. 상수 대상체를 가리키는 포인터와 동일한 타입의 일반 포인터를 선언한 후 이 포인터로 상수 대상체의 값을 바꿀 수 있다면 대상체를 제대로 보호할 수 없으며 그래서 상수 지시 포인터를 일반 포인터에 대입하는 것은 금지되어 있다.

만약 일반 포인터가 정 상수 포인터의 번지를 대입받도록 하고 싶다면 캐스트 연산자를 사용할 수는 있다. 상수 지시 포인터 타입(const int *)을 강제로 일반 포인터 타입(int *)으로 캐스팅하여 대입하면 일단 대입은 가능하다. 캐스트 연산자까지 동원해서 타입을 바꾸고자 한다면 컴파일러가 이를 굳이 말리지는 않는다. 물론 이런 코드는 바람직하지 않으며 꼭 필요할 때만 확실하게 안전하다는 검증을 한 후 사용해야 한다.

const 지정은 컴파일 타임에 컴파일러에 의해 지원된다. 컴파일러는 변수의 상수성을 보고 변경할 수 없는 값을 변경하는 코드에 대해 사정없이 에러 메시지를 출력한다. 그래서 보통의 정상적인 방법으로는 상수를 변경할 수 없다. 그렇다면 정상적이지 못한 변칙 코드로는 상수를 변경할 수도 있다는 얘기인데 런타임에 상수의 포인터로 간접적으로 값을 변경하는 것은 가능하다. 조금 엽기스럽기는 하지만 이왕 연구하는 김에 포인터에 의한 강제 변경을 테스트해 보자.

예 제 : ConstTest

#include <Turboc.h>

void main()

{

const int i=2;

int *pi=(int *)&i;

*pi=3;

printf("i=%d\n",i);

printf("*pi=%d\n",*pi);

const double d=1.0;

double *pd=(double *)&d;

*pd=2.3;

printf("d=%f\n",d);

printf("*pd=%f\n",*pd);

}

int, double 형 변수를 선언하고 비상수 포인터에 강제로 이 상수의 번지를 대입한 후 포인터로 값을 변경해 보았다. 이런 동작은 스팩에 정의되어 있지 않으므로 결과는 컴파일러마다 다르다. 다음은 비주얼 C++의 실행 결과인데 다소 혼란스러워 보인다.

i=2

*pi=3

d=2.300000

*pd=2.300000

double값은 바뀌지만 int값은 바뀌지 않은 것처럼 보인다. 그러나 내부를 들여다 보면 int도 실제로는 값이 바뀌지만 상수 참조문이 원래 정의된 상수값을 곧바로 사용하도록 컴파일하는 것이다. gcc로 이 예제를 테스트해 보면 둘 다 바뀌지 않는다. const 지정된 상수를 포인터로 강제 변경할 경우의 동작에 대해서는 정의되어 있지 않으므로 어떤 컴파일러가 틀렸다는 얘기는 할 수 없다.

컴파일러 개발자들은 스팩 문서대로 컴파일러를 작성할 뿐이므로 정의되지 않은 코드가 어떻게 컴파일될지는 알 수 없는 것이다. 따라서 우리는 이런 이식성이 없는 코드를 작성해서는 안된다. 다음은 인수로 전달된 상수 지시 포인터의 상수성을 변경하여 실인수를 변경해 보자. 함수는 임의의 실인수에 대해 동작할 수 있어야 하므로 컴파일러가 원래의 상수값을 특정값으로 가정할 수 없어 앞의 예제와는 효과가 조금 다르다.

예 제 : ConstTest2

#include <Turboc.h>

void func(const int *ai)

{

// *ai=3;

int *pi;

pi=(int *)ai;

*pi=3;

}

void main()

{

int i=2;

func(&i);

printf("%d\n",i);

}

func는 const int *를 전달받으므로 *ai=3 식으로 이 포인터가 가리키는 내용을 직접 변경하는 것은 당연히 불법이다. 그러나 비상수 포인터 pi로 강제 변경하는 것은 가능하다. 컴파일러는 pi가 가리키는 내용이 선언할 때부터 상수인지 아니면 실인수는 비상수인데 함수로 전달될 때만 상수인지는 전혀 분간할 수 없으므로 *pi=3 호출에 대해 무조건 값을 변경할 수밖에 없다. 이 코드는 거의 대부분의 컴파일러에 대해서 동작한다.