참조자

포인터로 다른 객체에 접근하려면 주소를 얻고, 쓸 때마다 *로 간접 참조하고, 비어 있지 않은지도 확인해야 했습니다. 대상이 반드시 있고 다른 객체로 바꿀 일도 없다면, 이 과정은 번거롭기만 합니다. 참조자(reference)는 이미 있는 객체에 다른 이름을 붙여, 그 이름을 원래 변수처럼 쓰게 해 줍니다.

이 글은 참조자를 선언하고 쓰는 방법, 포인터와 다른 점, 함수 매개변수와 반환값에 참조를 쓰는 방법, 읽기 전용인 const 참조를 다룹니다. 참조자를 이해하는 핵심은 참조자가 새 객체가 아니라 기존 객체의 별명(alias)이라는 점입니다.

참조자 선언

참조자는 타입 뒤에 &를 붙여 선언하고, 선언할 때 반드시 참조할 객체로 초기화합니다. 이 &는 포인터 기초에서 본 주소 연산자와 모양만 같고, 선언에서는 참조자라는 표시입니다.

#include <iostream>

int main() {
    int num = 10;
    int& ref = num;

    std::cout << num << ' ' << ref << ' '
              << std::boolalpha << (&ref == &num) << '\n';

    ref = 20;
    std::cout << num << ' ' << ref << '\n';

    num = 30;
    std::cout << num << ' ' << ref << '\n';
}

10 10 true
20 20
30 30

ref는 num의 다른 이름이므로 &ref는 num의 주소와 같습니다. ref = 20은 num에 20을 대입하고, num = 30은 ref로 읽어도 30이 나옵니다. 포인터와 달리 * 없이 원래 변수처럼 쓰며, 참조자가 내부적으로 저장 공간을 쓰는지는 구현이 정할 일입니다.

초기화와 재지정

참조자는 선언할 때 대상이 정해지고, 그 뒤로는 다른 객체를 참조하도록 바꿀 수 없습니다. 그래서 int& r;처럼 초기화 없이 선언하면 컴파일 오류입니다.

#include <iostream>

int main() {
    int val1 = 5;
    int val2 = 15;
    int& ref = val1;

    ref = val2;
    std::cout << val1 << ' ' << val2 << ' ' << ref << '\n';
}

15 15 15

ref = val2는 ref가 val2를 참조하게 바꾸는 것이 아니라, ref가 참조하는 val1에 val2의 값 15를 대입합니다. 그래서 val1이 15가 되고, ref는 여전히 val1의 별명입니다. 참조자에 대한 대입은 언제나 대상 객체에 대한 대입입니다.

사본, 별명, 포인터 구분하기

값이 우연히 같아도 같은 객체인지는 따로 확인해야 합니다. 다음 프로그램은 값 복사, 참조, 포인터를 한꺼번에 비교합니다.

#include <iostream>

int main() {
    int first = 5;
    int second = 15;
    int& ref = first;
    int saved = ref;
    int* p = &first;

    ref = second;
    p = &second;
    *p = 25;

    std::cout << first << ' ' << second << ' ' << ref << ' ' << saved
              << ' ' << std::boolalpha << (&ref == &first) << '\n';
}

15 25 15 5 true

아래 그림처럼 처음에는 ref와 p가 모두 first와 관계를 맺고, saved는 ref의 값 5를 복사한 별도의 int입니다. ref = second는 first에 15를 대입할 뿐 ref의 대상을 바꾸지 않고, p = &second는 포인터가 가리키는 대상을 바꾸므로 *p = 25는 second를 25로 만듭니다. saved는 그 뒤의 변화와 상관없이 처음의 5를 유지합니다.

int first = 5;
int second = 15;
int& ref = first;

ref = second;
// first가 15가 됨
// ref는 여전히 first의 별명

int first = 5;
int second = 15;
int& ref = first;

ref = second;
// first가 15가 됨
// ref는 여전히 first의 별명

참조자에는 빈 상태가 없지만, 대상 객체가 먼저 사라지면 허상 참조(dangling reference)가 됩니다. 허상 포인터처럼, 수명이 끝난 객체를 참조자로 쓰는 것도 정의되지 않은 동작입니다.

함수 매개변수로 쓰기

함수의 정의와 호출에서 본 값 매개변수는 인자의 사본이어서, 함수 안에서 바꿔도 호출한 쪽의 변수는 그대로였습니다. 매개변수를 참조로 선언하면 매개변수가 인자로 넘긴 변수 자체의 별명이 되므로, 함수가 호출한 쪽의 변수를 바꿀 수 있습니다.

#include <iostream>

void increment(int& value) {
    ++value;
}

void swapValues(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int count = 10;
    increment(count);

    int x = 1;
    int y = 2;
    swapValues(x, y);

    std::cout << count << ' ' << x << ' ' << y << '\n';
}

11 2 1

increment(count)의 value는 count의 별명이어서 ++value가 count를 11로 만들고, swapValues(x, y)는 x와 y의 값을 맞바꿉니다. 같은 일을 포인터로 하려면 swapPointers(&x, &y)처럼 호출할 때 주소를 넘기고 함수 안에서 *a로 간접 참조해야 하지만, 참조를 쓰면 호출이 간결하고 널 검사도 필요 없습니다. 대신 호출문 swapValues(x, y)만 보고는 인자가 바뀐다는 것을 알 수 없으므로, 함수 이름이나 선언으로 바뀐다는 것이 드러나게 합니다.

const 참조

참조를 const로 선언하면 그 참조로는 대상을 읽기만 하고 바꿀 수 없습니다. 복사하지 않으면서 원본이 바뀌지 않는다는 것도 보장하므로, 문자열이나 컨테이너처럼 복사 비용이 큰 인자를 읽기만 할 때 씁니다.

#include <iostream>
#include <string>

void printName(const std::string& name) {
    // name += "!"; // 컴파일 오류: const 참조로는 바꿀 수 없음
    std::cout << "name: " << name << '\n';
}

int main() {
    std::string user = "Ada";
    printName(user);
    printName("Grace");
}

name: Ada
name: Grace

const 참조는 수정할 수 있는 참조와 달리 임시 객체에도 묶일 수 있습니다. printName("Grace")에서는 리터럴로 임시 std::string이 만들어져 name에 묶이고, 함수 호출이 끝나면 사라집니다. 반면 int& r = 20;처럼 수정할 수 있는 참조를 임시 값에 묶는 것은 컴파일 오류입니다.

더 깊이: 임시 객체의 수명이 늘어나는 경우와 늘어나지 않는 경우

const std::string& name = std::string("Grace");처럼 지역 참조를 임시 객체에 묶으면, 그 임시 객체는 문장 끝에서 사라지지 않고 참조가 범위를 벗어날 때까지 살아 있습니다. 이 규칙은 임시 객체의 멤버나 배열 원소에 참조를 묶을 때도 적용되어, 임시 객체 전체의 수명이 늘어납니다.

하지만 수명이 늘어나는 것은 임시 객체를 직접 묶은 참조 하나에 대해서입니다. 함수의 참조 매개변수에 묶인 임시 객체는 그 호출이 들어 있는 식이 끝날 때 사라지므로, 받은 참조를 그대로 돌려주는 pick 같은 함수의 결과를 const std::string& r = pick(std::string("a"));로 받으면 r은 다음 문장에서 허상 참조가 됩니다. 이미 묶인 참조로 다른 참조를 초기화해도 수명은 다시 늘어나지 않으며, return 문에서 반환 참조에 묶인 임시 객체도 반환식이 끝나자마자 사라집니다. C++26부터는 이렇게 반환 참조를 임시 객체에 묶는 return 문을 컴파일 오류로 정했습니다.

그래서 수명이 늘어난다는 규칙에 기대기보다, 참조로 받은 값이 어디에서 왔는지를 따라가 보는 편이 안전합니다. 자세한 예외 목록은 cppreference의 참조 초기화 문서에 있습니다.

매개변수 형태 고르기

매개변수의 형태는 성능뿐 아니라, 함수가 인자를 어떻게 다룰지를 호출하는 사람에게 알려 줍니다. 아래 그림은 네 가지 형태를 고르는 기준입니다.

int나 double 같은 작은 값은 값으로 받는 편이 단순하고, 참조로 받아도 빨라지지 않습니다. const T&로 받은 객체는 빌린 것이므로, 함수가 그 참조를 저장해 두었다가 호출이 끝난 뒤에 쓰면 원본이 이미 사라졌을 수 있습니다.

참조를 반환하기

함수가 참조를 반환하면, 호출식이 그 대상 객체 자체를 나타내므로 호출 결과에 대입할 수도 있습니다. 아래 getCounter는 반환 타입이 int가 아니라 int&이며, main은 그 호출식을 대입의 왼쪽에 둡니다. 반환 타입이 int였다면 호출 결과는 이름 없는 임시 값이어서, 같은 대입이 컴파일되지 않습니다.

#include <iostream>

int counter = 100;

int& getCounter() {
    return counter;
}

int main() {
    getCounter() = 200;
    std::cout << counter << '\n';
}

200

getCounter()는 전역 변수 counter의 참조를 반환하므로, getCounter() = 200은 counter에 200을 대입합니다. 이렇게 참조를 반환하는 방식은 뒤의 장에서 볼 클래스의 멤버 접근 함수나 연산자 오버로딩에서 자주 씁니다.

반환하는 참조의 대상은 호출한 쪽이 쓰는 동안 살아 있어야 합니다. 함수의 지역 변수는 함수가 끝나면 사라지므로, 지역 변수의 참조를 반환하면 호출한 쪽은 허상 참조를 받게 됩니다. GCC는 기본으로 켜진 -Wreturn-local-addr로 지역 변수의 주소나 참조를 반환하는 코드를 경고합니다.

정리

• 참조자는 기존 객체의 다른 이름이며, T& r = 객체;처럼 선언할 때 반드시 대상으로 초기화합니다.
• 참조자의 대상은 바꿀 수 없으며, 참조자에 대입하면 대상 객체에 값이 대입됩니다.
• 포인터와 달리 * 없이 쓰고 빈 상태가 없지만, 대상이 사라지면 허상 참조가 됩니다.
• 참조 매개변수는 호출한 쪽의 변수를 바꿀 수 있고, const 참조 매개변수는 복사 없이 읽기만 합니다.
• const 참조는 임시 객체에 묶일 수 있지만, 수정할 수 있는 참조는 임시 값에 묶일 수 없습니다.
• 참조를 반환할 때는 대상이 호출한 쪽에서 쓰는 동안 살아 있어야 하며, 지역 변수의 참조는 반환하지 않습니다.

연습 문제

1. 대상이 바뀌지 않는 참조

copy_alias_pointer.cpp에서 *p = 25;만 second = 30;으로 바꾸면 출력은 무엇인가요? 그 뒤에 ref = 7;을 추가하면 second도 7이 되나요?

2. 값으로 받은 교환 함수

swapValues의 매개변수를 int a, int b로 바꾸면 swap_values.cpp의 출력은 어떻게 되나요?

3. 매개변수 형태 고르기

다음 세 함수에 알맞은 매개변수 형태는 무엇인가요? (가) 원소가 많은 std::vector<int>의 합을 구하는 함수 (나) 계산 결과를 호출자의 int 변수에 반드시 써 주는 함수 (다) 결과를 받을 변수를 넘기지 않아도 되는 함수

다음 글 포인터와 배열에서는 배열 이름이 첫 원소의 포인터로 바뀌는 규칙과, 포인터에 정수를 더해 다음 원소로 이동하는 포인터 산술을 다룹니다.