레퍼런스의 기본 개념과 메모리 구조

레퍼런스(Reference)는 이미 존재하는 변수에 붙이는 별칭(Alias)입니다. 레퍼런스를 통해 수행하는 모든 연산은 원본 변수에 직접 적용되는 것과 완전히 동일한 효과를 가집니다. 메모리 관점에서 레퍼런스는 자체적인 저장 공간을 할당받지 않으며, 원본 변수와 동일한 메모리 주소를 공유합니다.

레퍼런스를 선언할 때는 타입 뒤에 & 기호를 사용하며, 선언과 동시에 반드시 원본 변수로 초기화해야 합니다. 한 번 바인딩된 레퍼런스는 생명주기 동안 다른 변수를 가리키도록 재지정할 수 없습니다. 또한, 배열 전체를 가리키는 레퍼런스는 언어 문법상 허용되지 않습니다.

#include <iostream>

int main() {
    int originalValue = 10;
    int &aliasValue = originalValue;
    
    aliasValue = 20;
    std::cout << "Original: " << originalValue << ", Alias: " << aliasValue << "\n";
    
    int anotherValue = 30;
    aliasValue = anotherValue;
    std::cout << "Original: " << originalValue << ", Alias: " << aliasValue << "\n";
    
    return 0;
}

#include <iostream>

int main() {
    int numbers[] = {10, 20, 30};
    // int &arrRef = numbers; // 컴파일 오류: 배열을 직접 레퍼런스로 바인딩할 수 없음
    return 0;
}

함수 매개변수로서의 레퍼런스

함수에 데이터를 전달할 때 레퍼런스를 사용하면 값 복사에 따른 오버헤드를 완전히 제거할 수 있습니다. C언어에서는 대규모 데이터를 효율적으로 전달하기 위해 포인터를 사용했지만, 포인터는 역참조 연산과 널 포인터 체크 등 추가적인 복잡성을 동반합니다. 레퍼런스는 포인터와 동일한 수준의 성능을 제공하면서도 문법적으로 원본 변수를 다루는 것처럼 직관적인 코드를 작성할 수 있게 해줍니다.

#include <iostream>

void exchangeValues(int &first, int &second) {
    int temp = first;
    first = second;
    second = temp;
}

int main() {
    int num1 = 100, num2 = 200;
    exchangeValues(num1, num2);
    std::cout << "num1: " << num1 << ", num2: " << num2 << "\n";
    return 0;
}

상수 레퍼런스와 임시 객체 바인딩

함수 매개변수로 레퍼런스를 사용할 때, 원본 데이터의 수정을 방지해야 한다면 const 레퍼런스를 사용해야 합니다. 상수 레퍼런스는 데이터의 무결성을 보장할 뿐만 아니라, 우측값(R-value)인 임시 객체를 바인딩할 수 있는 특권을 가집니다. 일반 레퍼런스는 임시 객체에 바인딩될 수 없으므로, 함수가 리터럴이나 함수의 반환값을 인자로 받아야 할 때는 반드시 const 레퍼런스를 사용해야 합니다.

#include <iostream>
#include <string>

void processData(const std::string &data) {
    // data = "modified"; // 오류: 상수 레퍼런스는 수정할 수 없음
    std::cout << "Data: " << data << "\n";
}

int main() {
    std::string text = "Hello";
    processData(text);
    processData("Temporary String"); // 임시 객체에 바인딩
    return 0;
}

레퍼런스를 반환하는 함수

함수의 반환 타입으로 레퍼런스를 사용하면, 반환값을 수신할 때 발생하는 객체 복사를 방지할 수 있습니다. 이는 대규모 객체를 반환할 때 성능을 크게 향상시킵니다. 하지만 레퍼런스를 반환할 때는 수명에 각별히 주의해야 합니다. 함수가 종료되면서 소멸되는 지역 변수의 레퍼런스를 반환하면 댕글링 레퍼런스(Dangling Reference)가 발생하여 미정의 동작을 초래합니다. 또한, 함수 내부에서 동적 할당한 메모리의 레퍼런스를 반환하면 메모리 해제의 주체가 모호해져 메모리 누수가 발생할 수 있습니다.

#include <iostream>

int globalStorage = 0;

int& getStorageRef() {
    return globalStorage;
}

int main() {
    getStorageRef() = 42;
    std::cout << "Global storage: " << globalStorage << "\n";
    
    int &ref = getStorageRef();
    ref = 100;
    std::cout << "Global storage: " << globalStorage << "\n";
    
    return 0;
}

레퍼런스 반환은 함수 호출부를 좌측값(L-value)으로 사용할 수 있게 해줍니다. 이를 활용하면 배열의 특정 인덱스에 직접 접근하여 할당하는 것과 같은 직관적인 문법을 구현할 수 있습니다.

#include <iostream>

int buffer[5] = {0};

int& accessElement(int index) {
    if (index >= 0 && index < 5) {
        return buffer[index];
    }
    static int errorFallback = -1;
    std::cerr << "Index out of bounds\n";
    return errorFallback;
}

int main() {
    accessElement(0) = 10;
    accessElement(4) = 50;
    std::cout << "buffer[0]: " << buffer[0] << ", buffer[4]: " << buffer[4] << "\n";
    return 0;
}

연산자 오버로딩과 레퍼런스 반환

스트림 삽입 및 추출 연산자(<<, >>)와 할당 연산자(=)를 오버로딩할 때는 반드시 레퍼런스를 반환해야 합니다. 이러한 연산자들은 연속적인 체인 호출(예: std::cout << a << b; 또는 x = y = z;)을 지원해야 하기 때문에, 연산 결과로 객체 자체나 포인터가 아닌 스트림 및 객체의 레퍼런스를 반환해야 문법이 성립합니다. 반면, 사칙연산자(+, -, *, /)는 피연산자의 상태를 변경하지 않고 새로운 결과를 생성하므로, 레퍼런스가 아닌 값 자체를 반환하는 것이 원칙입니다.

다형성 구현과 레퍼런스

포인터와 마찬가지로 레퍼런스 역시 객체 지향 프로그래밍의 다형성(Polymorphism)을 구현하는 데 사용될 수 있습니다. 기본 클래스(Base Class)의 레퍼런스로 파생 클래스(Derived Class)의 객체를 바인딩하면, 가상 함수(Virtual Function) 호출 시 동적 바인딩이 발생하여 파생 클래스의 오버라이딩된 메서드가 실행됩니다. 포인터를 사용할 때보다 널 체크에 대한 부담이 적으며, 객체의 멤버에 접근할 때 화살표 연산자(->) 대신 점 연산자(.)를 사용할 수 있어 코드의 가독성이 향상됩니다.

#include <iostream>

class Base {
public:
    virtual void display() const { std::cout << "Base class\n"; }
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void display() const override { std::cout << "Derived class\n"; }
};

int main() {
    Derived derivedObj;
    Base &baseRef = derivedObj;
    baseRef.display(); // 다형성 동작
    return 0;
}