[C++] 참조자(Reference)

int num = 2010;

변수의 선언으로 num1이라는 이름으로 메모리 공간이 할당된다.

 

int &num2 = num1;

참조자의 선언으로 인해 num1의 메모리 공간에 num2라는 이름이 추가로 붙게된다.

num1이 하는 모든 연산은 num2로 하는 것과 동일한 결과를 보인다.

 

🟩 참조자는 기존에 선언된 변수에 붙이는 '별칭', 변수의 이름과 사실상 차이가 없다.

🟩 참조자의 수에는 제한이 없으며, 참조자를 대상으로 참조자를 선언할 수도 있다.

int num1 = 2579;
int& num2 = num1;
int& num3 = num2;
int& num4 = num3;

 

🟩 참조자의 선언 가능 범위

int &ref = 20; (X) 상수 대상으로의 참조자 선언은 불가능
int &ref; (X) 참조자는 생성과 동시에 누군가를 참조해야 한다.
int &ref = NULL; (X) 포인터처럼 NULL로 초기화하는 것이 불가능

 

참조자는 선언과 동시에 누군가를 참조해야 하는데, 그 참조의 대상은 기본적으로 변수가 되어야 한다.

그리고 참조자는 참조자의 대상을 변경할 수 없다.

 

변수의 성향을 지니는 대상이라면 참조자 선언이 가능하다. 예) 배열의 요소

int arr[3] = {1,3,5};
int& ref1 = arr[0];
int& ref2 = arr[1];
int& ref3 = arr[2];

 

포인터 변수 대상의 참조자 선언

int num = 12;
int* ptr = &numl
int** dptr = &ptr;

int& ref = num;
int* (&pref) = ptr;
int** (&dpref) = dptr;

 

🟩 call-by-reference : 주소값 / 참조자 이용

포인터 ptr에 전달된 주소값의 관점에서 보면 이는 call-by-value

int* SimpleFunc(int* ptr) {
	return ptr + 1;
}

 

주소값을 받아서 외부에 있는 메모리 공간에 접근하면 call-by-reference

int* SimpleFunc(int* ptr) {
	if (ptr == NULL) {
 		return NULL;
	}
 
	*ptr = 20;
	return 0;
}

 

참조자를 이용한 call-by-reference

🌟 매개변수 : 함수가 호출될 때 선언이 되는 변수로, 함수의 호출 과정에서 선언과 동시에 전달되는 대상으로 초기화된다. 즉, 매개변수에 선언된 참조자는 여전히 선언과 동시에 초기화된다.

int main(void){
	int val1 = 10;
    int val2 = 20;
    SwapByRef(val1, val2);
    cout << "val1 : " << val1 << endl;
    cout << "val2 : " << val2 << endl;
    return 0;
}

void SwapByRef(int &ref1, int &ref2){
	int temp = ref1;
    ref1 = ref2;
    ref2 = temp;
}

 

🟩 const 참조자

함수의 정의 형태와 함수의 호출형태를 보아도 변경 유무를 알 수 없다.

이를 알려면 HappyFunc 함수의 몸체 부분을 확인해야 하는데, 이는 큰 단점이다 (굳이)

// 함수 호출
int num = 24;
HappyFunc(num);

// 함수 정의
void HappyFunc(int &ref){}

 

const 사용

함수 HappyFunc 내에 참조자 ref를 이용한 값의 변경은 허용하지 않겠다는 의미

 

🌟 장점

함수의 원형 선언만 봐도 값의 변경이 일어나지 않음을 판단 가능

실수로 인한 값의 변경이 일어나지 않는다.

void HappyFunc(const int& ref){}

 

const int num = 20;
int &ref = num;     // error
ref += 10;
cout <<  num << endl;

// solution
const int num = 20;
const int& ref = num;
const int& ref = 50;

2번째 줄 👉 ref를 통한 값의 변경을 허용한다는 뜻 (num은 현재 const이기 때문에 허용되지 않음)

따라서, 한 번 const 선언이 들어가기 시작하면 관련해서 몇몇 변수들이 const로 선언되어야 하는데, 이는 프로그램의 안전성을 높이는 결과로 이어지기 때문에, const 선언을 빈번히 하는 것은 좋은  습관이다.

 

const 참조자는 상수를 참조 가능하다. 어떻게? const int& ref = 30;

상수를 const로 참조할 경우, 상수를 메모리 공간에 임시적으로 저장하기 때문이다.

즉, 행을 바꿔도 소멸하지 않는다. 매개변수형이 참조자인 경우에 상수를 전달할 수 있도록 하기 위함이다.

int Adder(const int& num1, const int& num2){
	return num1+num2;
}

 

🟩 반환형이 참조, 반환도 참조로 받는 경우

반환형 : int & RefRetFuncOne

반환 : int & num2

int & RefRetFuncOne(int& ref){
	ref++;
    return ref;
}

int main(void){
	int num1 = 1;
    int& num2 = RefRetFuncOne(num1);
    num1++;
    num2++;
    return 0;
} // 결과 모두 4, num1 = num2 = ref

 

🟩 반환형은 참조, 반환은 변수로 받는 경우

반환형 : int & RefRetFuncOne

반환 : int num2

int & RefRetFuncOne(int& ref){
	ref++;
    return ref;
}

int main(void){
	int num1 = 1;
    int num2 = RefRetFuncOne(num1);
    num1+=1;
    num2+=100;
    return 0;
} // num1 = ref = 3, num2 = 102

 

🟩 참조를 대상으로 값을 반환

참조자를 반환하건, 변수에 저장된 값을 반환하건, 반환형이 참조형이 아니라면 차이가 없다.

어차피 참조자가 참조하는 값이나 변수에 저장된 값이 반환되기 때문

int main(void){
	int num1 =  1;
    int num2 = RefRetFuncTwo(num1);
    num1 += 1;
    num2 += 100;
    cout << num1;
    cout << num2;
    return  0;
}

int RefRetFuncTwo(int &ref){
	ref++;
    return ref;
}

 반환형이 참조형인 경우에는 반환되는 대상을 참조자로 그리고 변수로 받을 수 있다.

👉 int num2 = RefRetFuncOne(num1); (O)

👉 int &num2 = RefRetFuncOne(num1); (O)

 

그러나 반환형이 값의 형태라면, 참조자로 그 값을 받을 수 없다.

👉 int num2 = RefRetFuncTwo(num1); (O)

👉 int &num2 = RefRetFuncTwo(num1); (X)

 

🟩 잘못된 참조 반환

지역변수를 참조의 형태로 반환하는 것

ref가 참조하는 대상이 소멸된다.

int& RetuRefFunc(int n){
	int num = 20;
    num += n;
    return num;
}

int &ref = RetuRefFunc(10);