[C++] 14. 참조자(Reference)

 

 

 

 

✅ 참조자(Reference)

참조자는 포인터와 상당히 유사한 개념이다. C에서는 포인터만 있었지만 C++에서는 참조자(Reference)라는 개념이 도입되면서 좀 더 편하게 주소값에 접근할 수 있게 되었다. 사실 C++에서도 포인터에 의존하고 싶지 않았고 *과 ->를 줄이고 싶었다고 한다.

 

우리가 메모리 공간을 할당하고 변수라는 것으로 이름을 지어준다. 참조자는 이 이름에 별명을 붙여주는 것이다. 예를 들어 '근호'의 별명이 '근또리'라고 했을 때 '근호'에게 과자를 주는 것과 '근또리'에게 과자를 주는 것은 동일하다.

 

결국, 참조자는 또 다른 이름을 부여하는 것과 같다고 보면 된다.

#include <iostream>

using namespace std;

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

    cout << var << endl;
    cout << ref << endl;

    cout << &var << endl;
    cout << &ref << endl;

    ref = 20;

    cout << var << endl;
    cout << ref << endl;
}

// 실행결과
// 10
// 10
// 0004D7F3
// 0004D7F3
// 20
// 20

 

코드에서 참조자와 var는 결국 같은 메모리공간을 바라보기 때문에 값과 주소 값 모두 같다.

 

 

✅ Call by Pointer vs Call by Reference

#include <iostream>

using namespace std;


void swapByPointer(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

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

int main()
{
    int var1 = 55;
    int var2 = 77;

    swapByPointer(&var1, &var2);

    cout << var1 << endl;
    cout << var2 << endl;

    swapByReference(var1, var2);

    cout << var1 << endl;
    cout << var2 << endl;
}

// 실행결과
// 77
// 55
// 55
// 77

 

Call by Value와 Call by Reference가 더 익숙하다. 여기서 레퍼런스는 참조자를 의미한다기 보단 더 넓은 범위로 값만 복사 하는 파라미터, 원본 값을 참조하는 파라미터로 쓰인다.

C++에서는 Call by Reference의 두 가지, 포인터와 참조자로 함수 인자 전달 방식이 있고 그 차이가 위 코드이다. 코드는 문제 없다. 

 

여러분들이 보기에 어느 쪽이 더 보기 편하고 쓰기 편한가? 10명 중 10명은 참조자에 의한 방식이 좋다고 할 것이다. 포인터처럼 주소값 연산자(&)와 포인터 값에 접근하기 위한 연산자(*)를 쓸 필요가 없다.

 

참조자에 의한 전달 방식에서 파라미터 int &a, int &b는 실제 전달된 인자 var1, var2가 대입되서 a, b가 각각 var1, var2를 참조(별명 생성)하는 방식이다. 따라서 a, b가 변경되면 var1, var2는 당연히 변경된다.

 

 

✅ 참조자(Reference)와 포인터(Pointer)의 차이점

참조자가 단순히 쓰기 편해서 쓰는 것일까? 그 외 포인터와 다른 점이 하나도 없을까?

 

차이점이 있다.

 

✔️첫 번째, 참조자는 Null을 허용하지 않는다.

참조자는 선언시 반드시 어떤 대상을 참조해야만 한다. int &ref; 혹은 int &ref = nullptr;은 불가능하다. 보통 우리가 별명을 지을 때 별명부터 지어놓고 그 대상을 찾진 않는다. 대상을 생각하면서 별명을 짓는 것과 동일하다.

이 부분이 참조자가 안정성을 갖추고 있다는 점이다. 포인터는 null을 허용하기 때문에, null에 잘못 접근하면 SIGSEGV를 만나게 된다. 그래서 포인터 값의 유효성 검사를 항상 해줘야하지만 참조자는 그럴 필요가 없다.

 

✔️두 번째, 참조자는 참조 대상을 변경할 수 없다.

포인터로 선언된 ptr1이 var1을 가리키고 있다고 가정하자. ptr1이 var2를 가리키도록 변경했다. 문제가 없다. 하지만 참조자는 이를 허용하지 않는다.

아래 코드를 보자.

#include <iostream>

using namespace std;

int main()
{
    int var1 = 5;
    int var2 = 3;

    int &ref1 = var1;
    ref1 = var2;
	
    cout << &var1 << endl;
    cout << &var2 << endl;
    cout << &ref1 << endl;
    
    cout << var1 << endl;
    cout << var2 << endl;
    cout << ref1 << endl;
}
// 실행결과
// 000CA683
// 000CF42B
// 000CA683
// 3
// 3
// 3

만약 ref1이 참조하고 있는 변수를 var2로 바꾸려고 ref1 = var2를 하면 의도한 대로 작동하지 않는다. 이는 var1 = var2를 실행한 셈이 된다. 따라서 여전히 ref1은 var1과 같은 메모리 주소를 갖고 있고, 값만 5에서 3으로 복사되었다.

혹시 헷갈린다면 ref1을 모두 var1로 바꿔 보면 이해가 빠를 것이다.(이름과 별명은 동일한 사람이니까)

 

✔️세 번째, 참조자는 메모리 공간을 소모하지 않는다.

포인터는 주소 값을 저장하기 위해 별도의 메모리 공간을 소모한다. 하지만 참조자는 같은 메모리 공간을 참조하므로 메모리 공간을 소모하지 않는다.

 

이는 Call by Reference에서도 인자 전달에 의한 메모리 소모가 없다는 것을 의미하기 때문에 메모리 측면에서도 포인터보다 효율적이다.

 

 

✅ 실무에서의 참조자 사용

// Function Parameter
inline void updateLastPrices(const std::string& symbol, const std::pair<double, double>& prices)
{
    std::lock_guard<std::mutex> lk(lastPricesMx);
    lastPrices[symbol] = prices;
}

// Reference
for (const auto& elem : Data)
{
    const auto& type = elem.firstReq.detail.type;
    auto& ticket = elem.firstReq.detail.ticket;

    if ( type == CHANGE )
    {
        ticket += 10;
    }
}

실무에서는 Call by Reference를 매우 많이 사용한다. 어쩔 수 없이 포인터를 넘겨야 할 때를 제외하고는 대부분의 클래스 인턴스를 참조자로 넘긴다.

여기서 자주 쓰는 패턴은, INPUT값은 const XXXX&, OUTPUT값은 XXXX& 형태로 넘긴다. 즉, 값에 의한 복사가 이루어지지 않도록 참조자를 쓰되, const를 붙여서 상수임을 보장하고, 원본 값의 변경이 필요한 경우에만 const를 붙이지 않는 방식이다.

 

그리고 참조자를 별칭처럼 쓰는 방식이 있다.(코드에서 Reference부분). elem.firstReq.detail.XXXX와 같이 변수가 여러 번 클래스 형태로 멤버변수를 가질 때 참조자로 해당 변수를 별명으로 만든다.

그리고 편하게 줄여서 type, ticket과 같이 사용한다. 여기서 type은 변경될 일이 없으므로 const auto& type; 으로 표현했고, ticket은 변경이 있으므로 const를 뺐다.

 

 

이처럼 참조자는 원본 값의 변경이 없는 경우에는 const를 붙이는 것이 좋다.