1-3.레퍼런스

1.변수의 별명

레퍼런스(Reference)는 변수에 대해 별명(alias)를 정의하여 이름을 하나 더 붙인다. 포인터와 유사한 파생형이며 사용하는 방식도 비슷하지만 차이점도 많다.

타입 &변수 = 대상체;

포인터는 구두점 *를 붙이는데 비해 레퍼런스는 구두점 &를 붙인다. 처음 선언할 때 대상체를 정해야 하므로 초깃값으로 대상체를 반드시 지정해야 한다.

ref1

#include <stdio.h>

int main()

{

int i = 3;

int &ri = i;

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

ri++;

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

printf("i번지 = %x, ri번지 = %x\n", &i, &ri);

}

실행결과	i = 3, ri = 3 i = 4, ri = 4 i번지 = 5dfe7c, ri번지 = 5dfe7c

정수형 변수 i를 선언하며 3으로 초기화했다. 정수형 레퍼런스 ri를 i로 초기화하면 i에 대해 ri라는 별명이 하나 더 생긴다. 이후 i와 ri는 완전히 동일한 대상을 가리켜 둘 중 하나를 바꾸면 나머지 하나도 같이 바뀐다. ri를 1 증가시키면 ri 뿐만 아니라 i도 같이 증가되어 둘 다 4가 되며 반대로 i를 변경하면 ri도 같이 바뀐다. 두 변수가 저장되어 있는 번지를 출력해 보면 메모리 위치가 같다.

저장되어 있는 주소가 같으니 두 변수는 이름만 다른 완전히 같은 변수이다. 일상 생활에서 사용하는 별명이라는 용어와 개념적으로 일치한다. 다음은 레퍼런스의 일반적인 특징 및 주의 사항이다.

■ 별명은 같은 타입에 대해 붙이는 것이어서 레퍼런스와 대상체는 타입이 완전히 일치해야 한다.

int i;

int &ri = i; // 가능

double &rd = i; // 에러

short &rs = i; // 에러

unsigned &ru = i; // 에러

정수형(int) 변수 i의 레퍼런스는 반드시 정수형(int)이어야 한다. 실수형 레퍼런스로는 i의 별명을 만들 수 없으며 심지어 int형과 호환되는 short, unsigned 형으로도 별명을 만들 수 없다.

■ 레퍼런스의 대상체는 실제 메모리를 점유하고 있는 좌변값이어야 한다. 상수는 좌변값이 아니므로 레퍼런스를 만들 수 없고 비트필드도 주소가 없어 레퍼런스의 대상체가 될 수 없다.

int &ri = 123;

이 선언이 허용된다면 ri = 456; 대입문으로 상수값을 바꿀 수 있으니 말이 안된다. 단, const 지시자를 붙이면 상수를 가리킬 수 있다.

const int &ri = 123;

이 경우 대상체가 상수여서 ri는 읽기만 할 뿐 쓸 수는 없다. 상수 레퍼런스는 const int ri = 123; 식으로 상수를 선언하는 것과 아무 차이가 없어 실용성이 없다.

■ 레퍼런스는 생성할 때 대상체를 분명히 지정해야 한다. 포인터는 일단 선언만 해 놓고 차후에 가리킬 변수의 번지를 대입할 수 있다. 그러나 레퍼런스는 처음 만들 때부터 누구의 별명인지 명확히 지정해야 하며 널 레퍼런스를 인정하지 않는다.

int *pi; // 가능 pi = &i;

int &ri; // 에러 ri = i;

초깃값이 없는 int &ri; 선언문 자체가 에러이다. 단, 다음의 경우에는 예외적으로 초깃값없이 레퍼런스를 선언할 수 있다.

① 함수의 형식 인수로 사용되는 레퍼런스. 호출될 때 실인수의 별명으로 초기화된다.

② 클래스의 멤버로 선언된 레퍼런스. 생성자에서 초기화한다.

③ 변수를 extern 선언할 때는 외부에서 이미 대상체가 지정되어 있다는 뜻이다.

이 경우도 호출 시점이나 객체 생성 시점으로 초기화가 연기되는 것 뿐이지 대상체 없이 레퍼런스를 선언하는 것은 아니다. 레퍼런스는 반드시 대상체가 있어야 한다.

■ 레퍼런스는 선언할 때 초기화되어 같은 대상체를 계속 가리킨다. 실행중에 참조 대상을 변경할 수 없다.

ref2

#include <stdio.h>

int main()

{

int i = 3, j = 7;

int &ri = i;

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

ri = j;

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

}

실행결과	i=3, ri=3, j=7 i=7, ri=7, j=7

ri를 i의 별명으로 초기화해 놓고 중간에 ri = j 대입문으로 ri를 변경했는데 그런다고 해서 ri가 j의 별명이 되는 것은 아니다. ri = j 대입문에서 ri가 i의 별명이므로 이 식은 i = j와 같다. 레퍼런스에 대한 대입 연산자는 대상체를 변경하는 것이 아니라 대상체의 값을 변경한다. 레퍼런스의 대상체는 선언할 때 딱 한 번만 초기화할 수 있다.

■ 레퍼런스에 대한 모든 연산은 대상체에 대한 연산이다. 정수형 레퍼런스 ri에 대해서는 정수에 대해 사용할 수 있는 모든 연산을 다 적용할 수 있으며 효과도 같다. 증감, 곱셈, 나머지, 쉬프트 등은 물론이고 주소 연산자 &도 사용할 수 있다. 일부 연산만 사용할 수 있는 포인터와 다른 점이다.

2.레퍼런스 인수

같은 함수 내에서 똑같은 변수에 대해 이름을 두 개 만드는 것은 사실 쓸데없는 짓이다. 레퍼런스를 함수의 인수로 전달할 때 실용적인 위력을 발휘한다. 함수가 실인수에 대한 별명을 가지면 실인수를 직접 조작할 수 있어 완전한 참조 호출이 된다. 1권 8장에서 포인터로 참조 호출을 구현한 byref 예제를 레퍼런스로 만들어 보자.

callref

#include <stdio.h>

void plusref2(int &ra)

{

ra = ra + 1;

}

int main()

{

int a = 5;

plusref2(a);

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

}

실행결과

a = 6

실행 결과는 byref 예제와 같다. plusref2 함수는 인수로 전달된 정수값을 1 증가시킨다. 5의 값을 가지는 a를 레퍼런스로 전달했고 plusref2 함수는 이 변수를 ra 레퍼런스로 받아 1 증가시켰으므로 결국 실인수 a의 값이 증가된다. 포인터를 사용한 예제와 어떤 점이 다른지 보자.

■ 함수는 포인터가 아닌 레퍼런스를 인수로 받는다. 그래서 plusref2 함수 내에서 형식 인수 ra는 실인수 a와 완전히 같은 변수가 되며 ra를 바꾸면 a도 바뀐다.

■ 번지가 아니라 변수 자체를 받았으므로 함수 본체에서 형식 인수를 참조할 때 *연산자를 붙이지 않고 ra 자체를 바로 액세스한다. 구조체를 받았다면 -> 연산자가 아닌. 연산자로 멤버를 읽는다.

■ 함수 호출부에서도 변수의 번지인 &a를 넘기지 않고 변수 그 자체인 a를 전달한다. 값 호출을 할 때와 호출 형식이 같다.

값 호출은 값만 받기 때문에 함수 내부에서 실인수를 변경할 수 없고 구조체같이 큰 데이터는 복사 시간이 오래 걸린다. 포인터나 레퍼런스를 받는 참조 호출은 번지나 별명을 받기 때문에 실인수를 변경할 수 있고 전달 속도도 빠르다.

포인터에 비해 레퍼런스를 받는 방법은 형식인수를 이름으로 참조할 수 있어 깔끔하다. 포인터가 가리키는 실인수를 참조하기 위해 일일이 *를 붙이는 것은 무척 귀찮은 일이고 실수로 *를 빼 먹으면 엉뚱한 동작을 할 수 있다. 특히 이중 포인터를 넘길 때는 레퍼런스가 더 직관적이다.

refptr

#include <stdio.h>

#include <malloc.h>

#include <string.h>

void InputName(char *&Name)

{

Name = (char *)malloc(32);

strcpy(Name, "kim sang hyung");

}

int main()

{

char *Name;

InputName(Name);

printf("이름은 %s입니다.\n", Name);

free(Name);

}

실행결과	이름은 kim sang hyung입니다.

15장에서 만들었던 ptrref 예제를 레퍼런스로 바꾸어 보았다. char *&Name인수가 포인터의 레퍼런스이다. T형의 레퍼런스는 T &이며 char * 자체가 하나의 타입이므로 이 타입에 대한 레퍼런스는 char *&이다. char &*가 아님을 주의하자. 포인터 자체를 받았으므로 Name이라는 이름으로 메모리를 할당하고 여기에 문자열을 복사해 넣으면 된다.

또 포인터는 잠재적 배열이어서 주변값을 마음대로 건드릴 수 있는데 비해 레퍼런스는 대상체만 액세스할 수 있어 더 안전하다. 그러나 호출부의 형식이 값 호출과 같아 함수 원형을 봐야만 참조호출인지 값호출인지 알 수 있는 번거로움이 있다. 그래서 레퍼런스를 받는 함수는 이름 뒤에 Ref나 ByRef 등을 접미를 붙이는 것이 좋다.

셀프 테스트

1-3. 두 개의 정수 인수 x, y를 레퍼런스로 받아 좌표값을 입력받는 getposition 함수를 작성하라. 함수 자체는 리턴값이 없어도 무방하다.

3.레퍼런스의 대상체

기본형은 물론이고 포인터에 대해서도 레퍼런스를 선언할 수 있다. 별 실용성은 없지만 배열이나 함수에 대한 레퍼런스도 가능하다. 그러나 모든 타입에 대한 레퍼런스를 다 선언할 수 있는 것은 아니며 일부 불가능한 형식도 있다.

■ 레퍼런스에 대한 레퍼런스는 선언할 수 없다. 레퍼런스가 별명인데 별명에 대해 또 다른 별명을 붙이는 것은 실용적 가치가 없기 때문이다. 포인터는 2중 포인터가 있지만 레퍼런스는 중첩을 허락하지 않는다.

int i;

int &ri = i;

int &rri = ri;

ri는 i에 대한 레퍼런스로 선언되었고 rri는 ri에 대한 레퍼런스로 선언되었다. 이때 rri가 2중 레퍼런스인 것처럼 보이지만 rri는 단순 레퍼런스에 불과하다. ri가 i이므로 rri는 i의 또 다른 별명일 뿐이며 결국 rri와 ri는 같은 대상을 가리키는 다른 별명이다. int &&rri = i; 같은 선언문은 필요치 않으며 에러로 처리된다.

■ 포인터에 대한 레퍼런스는 가능하지만 역으로 레퍼런스에 대한 포인터는 선언할 수 없다.

int i;

int &ri = i;

int &*pri = &ri; // 에러

레퍼런스에 대한 포인터 pri 선언문은 에러로 처리된다. 개념적으로 레퍼런스에 대한 포인터는 레퍼런스의 대상체에 대한 포인터형이므로 단순 포인터와 같으며 굳이 레퍼런스의 포인터형을 정의할 필요가 없다. int *pi = &ri라는 선언은 가능하며 pi가 ri, 즉 i의 주소를 가리킨다.

■ 레퍼런스의 배열도 선언할 수 없다. T형 배열이란 곧 T형 포인터인데 레퍼런스에 대한 포인터를 선언할 수 없으므로 배열도 선언할 수 없다. i와 j에 대한 레퍼런스가 필요하면 각각 따로 레퍼런스를 선언해야 한다.

int i, j;

int &ra[2]={i,j}; // 에러

요약하자면 레퍼런스는 중첩할 수 없고 포인터나 배열같은 파생형을 만들 수 없다. T형에 대해 T형 포인터나 T형 배열도 항상 가능하지만 레퍼런스에 대해서는 예외가 적용된다. 문법적으로 불가능해서가 아니라 실용성이 없기 때문에 금지한다.

4.레퍼런스 리턴

함수가 레퍼런스 타입을 리턴할 수도 있다. 이렇게 되면 리턴되는 대상이 좌변값의 별명이다 보니 함수 호출문에 값을 대입하는 것이 가능해진다.

refreturn

#include <stdio.h>

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

int &GetAr(int i)

{

return ar[i];

}

int main()

{

GetAr(3) = 6;

printf("ar[3] = %d\n", ar[3]);

}

실행결과

ar[3] = 6

GetAr 함수는 ar 배열에서 i번째 요소를 찾아 그 요소의 별명을 리턴한다. GetAr(3)이 리턴하는 값은 ar[3]의 별명이며 이 요소는 온전한 좌변값이기 때문에 함수 호출문이 대입식의 좌변에 올 수 있다. GetAr이 찾은 배열 요소에 6을 대입한 후 출력해 보면 배열 요소가 변경되어 있다.

C의 함수는 값을 리턴하기 때문에 이런 형식을 쓸 수 없지만 레퍼런스는 좌변값이어서 함수 호출문에 뭔가를 대입할 수 있다. 큰 배열 arSome 에서 어떤 복잡한 조건으로 한 요소를 검색하여 변경하고 싶을 때 C 언어에서는 다음과 같이 한다.

int FindMatch(char *name, int value, bool bCase);

arSome[FindMatch(...)] = Data;

FindMatch 함수는 입력된 조건으로부터 배열 요소를 검색하여 그 첨자를 리턴한다. 호출원은 이 함수의 리턴값을 첨자로 사용하여 arSome 배열의 한 요소를 액세스한다. 첨자 연산자 [ ] 안에 함수 호출문이 들어가 복잡한데 레퍼런스를 리턴하면 더 간단해진다.

int &FindMatchRef(char *name, int value, bool bCase);

FindMatchRef(...) = Data;

FindMatchRef 함수는 조건에 맞는 요소를 찾아 그 요소 자체를 리턴하며 호출원은 리턴된 레퍼런스에 곧바로 값을 대입한다. 함수를 대입식의 좌변에 쓸 수 있다는 것은 무척 흥미롭지만 기존의 코드와 이질적이고 직관성이 떨어지므로 자재하는 것이 좋다. 그러나 다음에 배울 연산자 오버로딩에는 이 기법이 꼭 필요하다.

5.레퍼런스의 내부

레퍼런스는 굉장히 특수하고 신기해 보이지만 내부를 들여다 보면 포인터의 변형에 불과하다. 컴파일러는 레퍼런스를 포인터로 바꿔 컴파일하며 내부 구현도 포인터로 되어 있다. 이 절의 첫 번째 예제는 내부적으로 다음과 같이 컴파일된다.

int i = 3; int &ri = i; printf("i = %d, ri = %d\n", i, ri); ri++; printf("i = %d, ri = %d\n", i, ri); printf("i번지 = %x, ri번지 = %x\n", &i, &ri);

int i = 3; int *ri = &i; printf("i = %d, ri = %d\n", i, (*ri)); (*ri)++; printf("i=%d, ri=%d\n", i, (*ri)); printf("i번지 = %x, ri번지 = %x\n", &i, &(*ri));

int &ri = i; 선언문에 대해 컴파일러는 ri를 정수형 포인터로 생성하고 i의 주소값으로 초기화한다. 레퍼런스가 포인터이므로 대상체에 대해 암시적으로 & 연산자를 붙인다. 코드에서 ri를 참조하는 모든 문장에 대해 암시적으로 *연산자를 적용하여 ri가 가리키는 대상체를 읽는다. (*ri)가 곧 i와 같으니 ri는 i의 완전한 별명으로 동작한다. 참조호출을 하는 plusref2 함수는 다음과 같이 번역된다.

void plusref2(int &a) { a = a + 1; } plusref2(i);

void plusref2(int *a) { (*a) = (*a) + 1; } plusref2(&i);

plusref2 함수의 인수는 실제로는 정수형 포인터이며 본체에서 이 인수에 대해 일일이 * 연산자를 적용하여 실인수를 참조한다. 이 함수를 호출할 때 plusref2(i)로 실인수를 전달하면 plusref2(&i)로 해석하여 번지를 대신 전달한다.

내부적으로 포인터로 구현되어 있고 포인터의 대상체는 반드시 좌변값이어야 한다. 그러다 보니 레퍼런스의 대상체도 좌변값만 가능하며 상수는 쓸 수 없다. 다음은 레퍼런스를 리턴하는 GetAr 함수가 어떻게 번역되는지 보자. 이 함수도 마찬가지로 실제로는 포인터를 리턴한다.

int &GetAr(int i) { return ar[i]; } GetAr(3)=6;

int *GetAr(int i) { return &ar[i]; } (*GetAr(3))=6;

대상체의 번지를 리턴하며 호출문은 * 연산자를 적용하여 리턴된 대상체를 가리킨다. 함수가 리턴하는 것은 결국 번지라는 값이지만 이 번지에 * 연산자가 암시적으로 적용되어 좌변값이 되므로 함수 호출문이 좌변에 올 수 있다.

결국 레퍼런스는 컴파일러가 내부에서 절묘하게 조작하는 기만적인 포인터일 뿐이다. 하지만 레퍼런스는 주소를 읽고 내용을 액세스하는 &, * 연산자를 붙이는 과정이 자동화되어 있어 코드가 간결해지는 이점이 있다. 포인터에 대해 암시적 연산자를 붙여 일반 변수처럼 쓸 수 있게 해 주는 편의문법이다.

당장은 레퍼런스가 왜 필요한지 감을 잡기 어렵겠지만 여기서는 별명이라는 것만 이해하고 넘어가자. 클래스가 완전한 타입이 되기 위해서는 기능 뿐만 형식까지도 기본 타입과 일치시켜야 할 필요가 있는데 복사 생성자나 연산자 오버로딩에 레퍼런스가 유용하게 사용된다.