C++ The difference between C and C ++.

C++ The difference between C and C ++.

1.C ++ basic functions

#include 
using namespace std;

void print_square(int arg);
int main()
{
    int i;

    cout << "제곱할 수 ? : ";
    cin >> i;

    print_square(i);
    
    return 0;
}

void print_square(int arg)
{
    cout << "전달된 인자 : " << arg*arg << endl;
}

C++와 C는 입출력 방법이 방법만 조금 다를 뿐, 다 똑같다.

아래 코드에서 void형의 (리턴값 X) 함수 print_square를 선언한다.

즉 arg* arg를 출력하는  것.

void print_square(int arg);
{
   cout << "전달된 인자: " << arg*arg << endl;
}

main 함수에서 인자로 i를 전달하고, print_square(i); 

따라서 arg에 i의 값이 들어가서 i * i인, 실행 결과의 경우 12를 전달해서 144가 출력된다.

2.C ++ The difference between C and C++.

#include 
using namespace std;
int change_val(int *p)
{
	*p = 3;

	return 0;
}
int main()
{
	int number = 5;

	cout << number << endl;
	change_val(&number);
	cout << number << endl;
}

일단 예시를 먼저 들겠다.

일단 레퍼런스(Reference)의 사전적 의미는 참조,참조.

C++에서는 흔히 참조자라고 한다.

위 소스코드를 보면 chage_val 함수에서 number 앞에 &를 붙이지 않고, change_val 에서도 *p = 3; 대신에 p = 3;으로 썼다. 대신 change_val에서 int &p를 받고 있다.

여기서 레퍼런스는 p가 number 변수의 다른 이름이 되는 것을 의미한다. 즉 p = 3; 이란 명령은 number = 3;를 말하는 것이다.

즉 레퍼런스는 int& ref = number;

int 타입 변수의 레퍼런스는 int&. 사용자가 마음대로 정의한 것이라고 할 수 있다.

유의해야 될 것은 반드시 정의 할 때 초기화가 되어야 된다는 것이다.

int &ref <= X. 

포인터 자체는 메모리 값을 보관하는 변수 자체로 활용될 수 있지만, 레퍼런스는 포인터처럼 메모리 공간에 할당되어서 자기 자신을 참조하는 *주소값을 보관하는 것이 아니라, 컴파일 시에 원래 가리키던 변수의 주소값으로 다 치환된다.

int a = 10;
int &ref = a;
int b = 3;
ref = b;

ref =b; 에서 ref가 b를 가리키는 것이 아니라,  a = b; 즉 a에 3이 대입되는 것. 

&ref = b; 와 같은 문장은 &a = b; 'a의 주소값을 3으로 변경?' 말도 안되는 소리고,

ref &=b;는 ref = ref & b; = a = a & b;와 같은 문장으로 의미가 다르다.

레퍼런스는 포인트로 치면 int const * 가장 중요한 것은 한 번 별명이 정해지면 절대 바꿀 수 없다.

3.C ++ Pointer vs Reference.

int number = 5;
int& ref = number;
int *p = &number;

ref++;
p++;

p++ 경우 p의 주소값이 4만큼 증가되어서 무언가를 가리키고 있고 ref++ 경우 ref = number++ 여기서는 6이다. 레퍼런스의 가장 큰 장점은 포인터 관련 연산들을 모두 생략 가능하다. 레퍼런스 이해를 위해. 

Ex==========

#include 
using namespace std;

int main()
{
        int x;
        int& y = x;
        int& z = y;
	
        x = 1;
	cout << "x : " << x << " y : " << y << " z : " << z << endl;

	y = 2;
	cout << "x : " << x << " y : " << y << " z : " << z << endl;

	z = 3;
	cout << "x : " << x << " y : " << y << " z : " << z << endl;
}

위의 소스 코드를 보면 int x; int& y = x; x에 대한 레퍼런스로 y를 정의한 것이다. int& y = x; int& z = y; 는 y가 int&이므로 z는 int&&가 되어야 하는데 이건 포인터에 해당하는 말이다. 즉 int x; int* y = &x; int **z = &y; 라고 쳐야 맞는 말이다. 다시 정리를 해보자면 int&y = x; int&z = y; y는 x의 레퍼런스이고, 'y'라고 표시한 것은 y를 그대로 'x'로 바꿔도 의미는 동일하다는 것이다. 결국 int&z = x; int&z = y; 는 100% 같은 문장이다. 레퍼런스는 포인터가 아니고, "특정 변수의 다른 이름" 이라고 정의하면 된다. x의 또 다른 이름인 y,z를 만든 것뿐이다. 물론 레퍼런스의 기능을 포인터로 대체할 수 있다는 것도 맞지만, 편리성에서는 차이가 있다. 앞에서 언급했던 cin도 레퍼런스 형태기에 &,"%d" 관심도 없다.

4.C ++ A reference to a constant.

예시를 통해 보자.

#include 
using namespace std;

int main()
{
      int &ref = 5;

      cout << ref << endl;
}

정상적인 C++ 코드 같은데 오류가 발생한다. 일단 소스 코드에 나온 상수 값 자체는 '리터럴 상수'이고, 레퍼런스 측면에서 보면, ref = 6;는 리터럴 값을 바꿀 수 있는 가능성이 있기에 불가능하다. 만약에 const int &ref = 5; 처러 상수 레퍼런스로 선언한다면 리터럴도 참조할 수 있다. 쉽게 말해 int a = ref; == a= 4; 와 동일.

5.An array of references and an array reference.

c를 공부해본 사람들이라면 이와 비슷한 주제를 본 적이 있을 것이다. 포인터의 배열 vs 배열 포인터 느낌과 비슷하게 C++에서는 레퍼런스로 주제를 잡겠다.

일단 레퍼런스는 반드시 정의와 함께 초기화를 해줘야 한다는 절대 조건이 있다. 

int a,b,c; int& arr[3] = {a,b,c}; 라는 간단한 코드가 있다고 하고 컴파일을 실행해봤지만, 에러가 뜬다. 일단 결론부터 말하자면, 레퍼런스의 포인터는 애초에 성립 자체를 하지 않는다.

레퍼런스는 메모리 상에 특정 공간을 차지하는 것이 아니라 컴파일 시에 원래 레퍼런스가 참조하던 변수의 주소값으로 대체된다고 했고, 메모리 공간을 차지하지 않는 것의 포인터를 생각한다는 것 자체가 말이 안된다.

반대로 배열의 레퍼런스를 보자.

#include 
using namespace std;

int main()
{
	int arr[3] = {1,2,3};
	int (&ref)[3] = arr;

	ref[0] = 2;
	ref[1] = 3;
	ref[2] = 1;

	cout << arr[0] << arr[1] << arr[2] << endl;
	return 0;
}

코드를 살펴보자.

int arr[3] = {1,2,3};
int (&ref)[3] = arr;

ref가 arr를 가리키도록 하였다. 위 코드대로 하면, ref[0]부터 ref[2]가 각각 arr[0]부터 arr[2]의 레퍼런스가 된다. 빈도로 봤을 때 레퍼런스는 잘 사용하지 않긴 하다. 이유는 배열의 크기를 정확히 명시해야 되기 때문이다. int(&ref)[5]라면 반드시 크기가 5인 int 배열을 가리켜야 하고, int(&ref)[5]라면 크기가 5인 배열을 가리켜야 한다. 반대로 포인터를 사용하면, 간단하게 int *p 하나로 모든 1차원 배열들을 가르킬 수 있으니, 만약에 배열을 가리킬 경우 포인터를 사용하는 것이 더 편리하다.

6.Functions that return references.

#include <iostream>
using namespace std;

int fn1(int &a) {
	return a;
}

int& fn2(int &a) {
	return a;
}
int main()
{
	int x = 1;
	cout << fn2(x)++ << endl;
	cout << "x :: " << x << endl;
}

x의 값이 바뀌었다. 이유는 fn2.

int& fn2(int &a) {
	return a;
}

fn2를 보면 인자로 레퍼런스를 받아서, 다시 그것을 그대로 리턴한다. 쉽게 말해 fn2(x)를 했을 때 fn2 내부에서 a는 x의 레퍼런스라고 인식한다. 다시 함수를 리턴할 때 x의 별명을 리턴한다고 인식한다. 즉 fn2(x)++은 x++를 한 문장과 동일하게 된 것이다. C언어였다면, x의 포인터를 리턴하고, 그걸 받아서 다시 역참조해서 (*)++를 했을 것인데, C++은 레퍼런스 덕분에 편리해졌다.