안산드레아스

C언어에서 Const 로 선언 하는 부분에 있어서는 특별하다.

어떤 특정 변수를 바뀌지 않는 "상수"로 선언하는 부분에 있어 보통 사용한다.

보통은 해당 코드에 대한 "안전성"을 위해 선언한다.  자세한 내용은 아래를 참고한다.

https://ansan-survivor.tistory.com/901

Const를 통한 포인터 변수 선언은, 해당 포인터변수가 가리키는 대상이 변하지 못하게 함을 의미한다.
아래와 같이 const int* ptr = &num 일 경우, 이제 ptr 포인터변수는 num의 주소값을 가리키는데, 이는 const 선언을 했기 때문에 항상 고정되며, ptr이 가리키는 방향에 대한 수정은 불가능 하다. (ptr -> num)

<const int * ptr 형태>

그러나! 그렇다고 num의 값을 못바꾸는 것은 아니다. ptr 변수가 const 이기 때문에, 가리키는 방향을 바꿀 수 없을 뿐 가리키는 대상인 num은 const가 아니기 때문에 변경이 가능하다.

#include <stdio.h>

int main()
{
    int num = 10;

    // ptr이 가리키는 대상은 항상 num으로 고정. 변경 불가
    const int* ptr = &num;

    // ptr이 가리키는 대상은 변경이 불가하다.
    // num은 가리킴을 받는 대상이고 const 선언이 아니므로 변경 가능
    // *ptr = 20; - 불가
    num = 30;

    return 0;
}

<int * const ptr 형태>

이번엔 const가 뒤에 변수명 앞에 선언되었다. 

ptr에 있는 주소값이 상수가 되어 변경이 불가능하다. 즉 ptr에는 &num1 주소값 외 아무것도 변경할 수 없다.

그러나 num1 내에 있는 값을 변경하는 것은 허용된다. (*ptr = 40 으로 값 변경 가능)

int main()
{
	int num1 = 20;
	int num2 = 30;

	//ptr이 가리키는 대상은 num1 으로 고정하겠다고 선언.
	int * const ptr = &num1;

	//ptr = &num2;	컴파일 에러! 왜? ptr은 num1만을 가리키는 포인터로 고정했으므로.
	*ptr = 40;	//ptr이 num1을 가리키고있고, 주소에 접근해서 변경은 할 수 있다.

	return 0;
}

<const int * const ptr 형태>

이는 매우 강력한 형태로,

ptr은 영원히 num을 가리키고 있고, num의 값을 아무도 변경할 수 없고 참조만 가능하다...

int main()
{
	int num = 1;
	
	// 두 const선언을 동시에 하는 방법.
	const int * const ptr = #
	// 즉, ptr은 영원히 num을 가리키고 있고, num의 값을 아무도 변경할 수 없고 참조만 가능하다...

}

C언어의 함수에 값을 전달하는 방법은 아래와 같다.

https://ansan-survivor.tistory.com/1224

그리고 함수에 전달하는 매개변수는 원래 값을 "복사"해서 전달한다.

따라서 원래 값은 바뀌지 않고, 전달된 매개변수가 input 인자에 전달되는 것이다.

위처럼 값 1개는 간단하게 복사하여 전달할 수 있다.

하지만 동시에 여러개 매개변수를 전달하고 싶은 경우 배열을 사용해야 하는데,

C언어의 함수에서 input인자로 배열전체를 복사에서 전달하는 것을 허용하지 않는다.

결론부터 말하자면, 배열의 주소값을 전달해서 포인터로 접근해야 한다.

왜냐하면 배열은 결국 포인터 형태이므로 (상수형 포인터)

https://ansan-survivor.tistory.com/1249

(상수형 포인터가 무슨말인지 모르면 아래 참고)

아래 코드는 배열의 주소값인 arr을 함수에 전달해서 함수에서 배열을 수정하는 코드이다.

#include <stdio.h>

// 배열을 전달을 받는 함수
// 받는 인자는 int형 포인터
void func(int * param)
{
    param[0] = 10;
    param[1] = 20;
    param[2] = 30;
}

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

    printf("맨처음 배열 값 {%d,%d,%d}\n", arr[0], arr[1], arr[2]);
    
    // 받는 input인자로 배열을 받아서 내부 값을 변경
    // 배열의 이름 arr은 'int형 상수형포인터' 이므로 전달 가능
    func(arr);
    
    printf("배열 내부값 변경 후 {%d,%d,%d}\n", arr[0], arr[1], arr[2]);

    return 0;
}

* 알아두기

배열을 받는 인자로 int * param 대신 int param[] 으로도 전달 가능하다.

어차피 둘다 동일한 의미이며, param 이라는 주소값을 참조한다.
만약 실제로 배열을 전달한다면, 후자의 방식으로 작성해서 코드의 가독성을 향상시킨다.

하지만 이러한 전달은 오직 배열만 가능하다!

// 배열을 받는 인자로 int * param 대신 int param[] 으로도 전달 가능하다.
// 만약 실제로 배열을 전달한다면, 후자의 방식으로 작성해서 코드의 가독성을 향상시킨다.
void func(int param[])
{
    param[0] = 10;
    param[1] = 20;
    param[2] = 30;
}

대부분 C언어를 배울때 맞닥드리는 예제로 변수의 값을 Swap하는 예제가 있다.

예를 들면 a, b 값이 있는데 a = 1 , b = 3 이 들어있다면 간단하게 이 두개의 값을 거로 바꾸는 예제이다.

해결방법은 아래와 같이 간단하다.

temp라는 임시변수에 잠시 값을 복사해두었다가 사용한다.

#include <stdio.h>

int main()
{
    int a = 1;
    int b = 3;

    // 두 값을 swap(바꾸기)
    printf("맨처음 값 a=%d, b=%d\n", a,b);
    
    // 값 변경을 위한 임시변수 선언
    int temp;
    temp = a;
    a = b;
    b = temp;
    
    printf("변경 후 값 a=%d, b=%d\n", a, b);

    return 0;
}

<포인터를 배운 후,  swap 함수 만들기>

함수와 포인터를 배운다면 이제 swap기능을 하는 함수를 만들라는 과제를 받는다.

함수 input 인자는 값을 복사하므로, swap기능을 사용하기 위해서는 주소값에 접근할 수 있는 포인터가 필요하다.

#include <stdio.h>


// 서로의 값을 바꿔주는 swap 함수
void swap(int* x, int* y)
{
    // 임시로 값을 저장할 변수 선언
    int temp;

    // temp에 x값을 저장해두기
    temp = *x;
    // x값을 y의 값으로 변경
    *x = *y;
    // x값을 저장하고 있는 temp의 값을 y에게 전달
    *y = temp;
}

int main()
{
    int a = 1;
    int b = 3;

    // 두 값을 swap(바꾸기)
    printf("맨처음 값 a=%d, b=%d\n", a,b);
    
    // 받는 input인자가 int형 포인터이므로, 주소값을 전달
    swap(&a, &b);
    
    printf("변경 후 값 a=%d, b=%d\n", a, b);

    return 0;
}

(결과) 이제 이 swap 함수를 지나면 2개의 값이 바뀌게 된다.

여러 문자열을 배열에 담아두고 필요할 경우 꺼내서 쓰고 싶은 경우가 있다.

결론부터 말하자면,

이 경우 char * 포인터 변수를 선언하고, 배열 내에 사용할 문자열을 넣으면 된다.

#include <stdio.h>

int main()
{
    // 문자열들을 저장하는 배열 선언, 3개의 문자열 저장
    char* strArr[3] = {"hello world", "nice to meet", "have a good"};

    // 문자열 출력하기
    printf("첫번째 : %s\n", strArr[0]);
    printf("두번째 : %s\n", strArr[1]);
    printf("세번째 : %s\n", strArr[2]);

    return 0;
}

(결과)

이는 char* 타입으로 선언된 포인터 변수 strArr은 각 문자열의 첫글자에 대한 주소값들을 저장하고 있는 것이다. 즉 각 문자열의 맨앞자리 알파벳의 주소값 3개 {'h'의 주소값, 'n'의 주소값, 'h'의 주소값} 를 담고 있는 것이다.

예를 들면 마치 {0x123A, 0x3B3F, 0x18C6} 과 같이 각 문자열의 시작하는 첫 알파벳의 주소를 담고 있는것과 비슷하다.

(이 원리에 대한 자세한 사항은 아래 참고)

https://ansan-survivor.tistory.com/1251

문자열(string)이란, 알파벳 하나하나가 메모리상의 연속적으로 나열되며, 마지막에는 '\0' (NULL)으로 끝나는 배열이다.

위 그림과 같이 문자열을 만드는 방법은 아래와 같다.

char string[11] = "hello world";

char이므로 한칸당 1byte를 사용하며, "~~"문자열 맨 뒤에 \0 (NULL)문자는 자동으로 들어가게 된다.

고로 띄어쓰기를 포함한 모든 문자들 공간과 마지막의 NULL이 들어갈공간을 포함해 11개의 공간을 선언했다.

C언어로 문자열을 표현하는 방법은 대표적으로 배열선언과 포인터 선언이 있다.

배열도 "상수형 포인터"로 결국 포인터와 동일한 역할을 한다. (아래 참고.)

https://ansan-survivor.tistory.com/1249

<배열으로 문자열 선언>

배열으로 선언하는 방법은 메모리공간을 미리 할당하는 방법과, 컴파일러가 문자열 길이를 보고 알아서 할당시켜주는 방법이 있다.

// 배열로 선언하는 방법. 메모리를 미리 할당함.
char string[11] = "hello world";

// 배열로 선언, 메모리 공간은 컴파일러가 알아서 할당 함.
char string[] = "hello world";

<포인터로 문자열 선언>

포인터로 선언하는 방법은 아래와 같이 간단하다. 하지만 여기서 string 이라는 변수는 포인터변수로 선언되었기에 주소값을 저장할 수 있다. 저 주소값은 문자열의 첫번째 항을 가리킨다. 즉, 아래 h문자를 가리키고 있다.

하지만 배열의 문자열 선언과 다른점은 "hello world"라는 문자열은 메모리 어딘가에 선언이 되었는데, 이는 상수형 문자열 특성을 지니므로 마음대로 문자하나하나를 변경할 수 없다. 

char* string = "hello world";

  원리는 아래 순서를 따른다.

1. 메모리 어딘가에 "hello world"가 할당된다.

2. char * string 변수가 선언된다.

3. string은 h의 주소값을 가리킨다. ( *string = 'h'  )

 포인터 변수 string은 h의 주소를 가리키므로  *string를 출력하면 'h'가 출력되고, (*string + 1)으로 출력하면 그 뒤에 있는 문자인 'e'가 출력된다. 단 "hello world" 전체는 상수형으로 할당되었기 때문에 임의로 배열을 변경할 수 없다.

다시말해 *string = 'k' 이런식으로 포인터로 값을 변경할 수 없다. 상수이기 때문에.

(배열로 선언하고 내부인자 변경가능)

#include <stdio.h>

int main()
{
    // 배열으로 문자열 선언
    char str1[] = "hello world";

    // 배열으로 선언한 문자열 내부인자는 변경 가능
    printf("변경전: %s\n", str1);
    str1[1] = 'k';
    printf("변경후: %s\n", str1);
    
    return 0;
}

(포인터로 선언하고 변경을 원할 시, 다른 문자열 주소를 넣어주어야 한다.)

#include <stdio.h>

int main()
{
    // 포인터로 문자열 선언
    // "hello world" 문자열은 상수형태로 변경 불가.
    char * str2 = "hello world";
    printf("변경전: %s\n", str2);

    // 문자열을 바꾸고 싶은경우 다른 문자열을 선언해야 함.
    str2 = "declare other string !";
    printf("변경후: %s\n", str2);

    return 0;
}

메모리 어딘가 상수형으로 선언된 문자열을 기존의 것은 버리고, 새로 변경된 문자열의 앞자리인 'd'를 가리키게 된다.

* 위 포인터 원리와 동일하게 만약 아래와같은 printf함수를 선언하면 이는 메모리 어딘가에 상수형 문자열을 만드는것과 동일하다.

즉, 메모리 어딘가 "hi nice to meet you" 라는 상수형 문자형을 할당하고, 이를 첫글자의 메모리 주소로 치환한다.

printf("hi nice to meet you");

즉 만약 첫글자의 'h' 의 문자열 주소가 0x0123 이라면, 컴퓨터가 이해하는 것은 아래와 같다.

printf(0x0123)

<여러 문자열을 품고있는 배열 포인터 선언>

https://ansan-survivor.tistory.com/1252

아래와 같은 배열선언과 배열값 변경 코드가 있다.

이를 포인터로 변환시키는 방법.

#include <stdio.h>

int main()
{
    int arr[3] = { 0, 1, 2 };
    // 배열 초기값 출력 해보기
    printf("arr[0] : %d\n", arr[0]);
    printf("arr[1] : %d\n", arr[1]);
    printf("arr[2] : %d\n", arr[2]);

    // 배열 값 변경하기
    arr[0] = 10;
    arr[1] = 30;
    arr[2] = 50;

    printf("변경된 배열 값\n");
    printf("arr[0] : %d\n", arr[0]);
    printf("arr[1] : %d\n", arr[1]);
    printf("arr[2] : %d\n", arr[2]);

    return 0;
}

<포인터로 변환하기>

#include <stdio.h>

int main()
{
    // int형 포인터변수 선언 및 초기화
    int* ptr = NULL;

    // int형 초기값 변수 선언
    int arr = 0;

    // arr 주소를 ptr 포인터변수의 주소값으로 할당
    ptr = &arr;

    // ptr뒤 배열에 각각 값 할당 (int형이므로 +1당 4byte씩 뒤로 주소값 증가)
    *(ptr + 1) = 1;
    *(ptr + 2) = 2;


    // 배열 초기값 출력 해보기
    printf("arr[0] : %d\n", ptr[0]);
    printf("arr[1] : %d\n", ptr[1]);
    printf("arr[2] : %d\n", ptr[2]);

    // 배열 값 변경하기
    ptr[0] = 10;
    ptr[1] = 30;
    ptr[2] = 50;

    printf("변경된 배열 값\n");
    printf("arr[0] : %d\n", ptr[0]);
    printf("arr[1] : %d\n", ptr[1]);
    printf("arr[2] : %d\n", ptr[2]);

    return 0;
}

(결과)

같은 결과가 나오게 된다.

ptr은 int형 포인터 (int*) 으로 선언했기 때문에, int형인 arr값의 주소를 받을 수 있다.

ptr = &arr;   arr의 주소값을 ptr에 넣었기 때문에 아래와 같이 표현이 가능하다.

*(ptr) 은 해당 주소 내부의 값을 리턴하는 명령이다. 

===============================

(알아두면 좋은 사항)

 포인터에서 많이 보는 연산자는 * 일것이다.

*를 어떤타입과 어느 위치에 쓰냐에 따라서 특색이 다 다르다.

1. 곱셈으로의 역할 (아래와 숫자 사이, 숫자를 가진 변수와 연산과 함께 쓰면 곱셈이다)

  int a = 1 * 2 ;
  int b = a * 3 ;

2. 포인터 선언에 대한 역할 (아래와 같이 포인터로 선언할때 사용한다.)

   포인터로 선언했기 때문에, 이제 ptr에는 int형 타입의 주소값을 저장할 수 있다.

  int * ptr;

3. 포인터가 가리키는 값에 대한 접근 (*ptr)

// 포인터 선언
int * ptr;
int num = 1;

// ptr에 num의 주소를 대입
ptr = &num

// *ptr을 이용해서 num주소에 있는 값을 출력할 수 있음
printf("ptr value is : %d", *ptr);

// *ptr을 이용해서 가리키고 있는 값을 바꿀 수 있음 (num값을 3으로 바꿈)
*ptr = 3;

포인터에 대한 간단한 설명은 아래 참고.

https://ansan-survivor.tistory.com/1237

포인터는 크게 상수형 포인터와 변수형 포인터로 나뉠 수 있다.

결론부터 말하자면, 배열을 선언하는 변수는 "상수형 포인터" 그 외는 "변수형 포인터"이다.

배열 선언시 char arr[ ]; 이런식으로 선언하는데 실제 arr 은 상수형 포인터다. 즉 주소값을 알고있는 Lable이다.

그래서 char * arr; 이랑 똑같은 구조라 할 수 있지만, * 로 선언하면 "변수"로 선언했기 때문에 포인터 변수의 주소값을 바꿀 수 있고,

char arr [ ] 으로 선언하면 상수이므로 그 주소를 바꿀 수 없다. 그리고 이 arr은 내 첫번째 배열값의 주소를 가리키고 있다.

(이때 arr의 자료형이 무엇이냐? 하면 포인터이므로 char * 자료형이다 라고 한다.)

<아래 그림의 예시 설명>

 - int arr[ ]; 으로 선언하면 int형크기(4 byte) 간격으로 나란히 배열되어있는 메모리의 주소를 선언하는 것이다.

 - 아래 그림의 화살표는 메모리상의 주소를 가리키는 것을 표현
 - arr 은 주소값을 저장할 수 있는 포인터이다. 그러나 가리키는 방향(화살표)를 바꿀 수 없는 "상수" 이다.

 - ptr 은 &num 같이 어떤걸 입력하냐에 따라 가리키는 방향(화살표)를 바꿀 수 있는 "변수"이다.

 - arr도 포인터기 때문에 *arr = 10과 같이 연산이 가능하다. (arr 첫번째 배열값 변경을 의미)

  <배열의 주소값 int 타입 확인>

     - 아래 결과를 보면, arr 의 주소는 첫번째 배열의 주소값인 &arr[0] 임을 알 수 있다.

     - 그리고 뒤 이어 배열의 값들은 int형이 4byte 임으로 순차로 4씩 증가함을 알 수 있다.

#include <stdio.h>

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


    // 배열의 각 주소값 확인
    // 자료형은 int이므로 4byte씩 증가
    printf("배열 주소: %p\n", arr);
    printf("첫번째 : %p\n", &arr[0]);
    printf("두번째 : %p\n", &arr[1]);
    printf("세번째 : %p\n", &arr[2]);

    return 0;
}

  <포인터를 이용해서 배열 내부값 조작 - 방법 1>

배열이 포인터 형태임을 알았으니, 포인터를 이용해서 배열 내부의 값들을 조작할 수 있다.

int * ptr = &arr[0] ;  은 arr의 첫번째 주소를 ptr으로 가리키는 것이다. (arr 자체가 주소값이므로 int * ptr = arr 으로도 사용 가능)

*ptr 는 배열의 첫번째 항의 값을 출력함으로 0을 리턴.

*(ptr + 1) 은 ptr의 주소값에서 +1 (int형이므로 4byte) 뒤로 더한곳으로 주소를 가리킨다.

#include <stdio.h>

int main()
{
    int arr[3] = { 0, 1, 2 };
    // 배열 초기값 출력 해보기
    printf("arr[0] : %d\n", arr[0]);
    printf("arr[1] : %d\n", arr[1]);
    printf("arr[2] : %d\n", arr[2]);


    // 배열을 조작할 포인터 선언, arr[0] 첫번째 주소를 가리킴.
    int* ptr = &arr[0];

    // 첫번째 값 바꾸기
    *ptr = 10;
    // 두번째 값 바꾸기, 자료형이 int이므로 1씩 증가하면 4byte씩 뒤로 이동.
    *(ptr + 1) = 30;
    // 세번쨰 값 바꾸기
    *(ptr + 2) = 300;

    // 배열 출력해보기
    printf("변경 후 배열 출력\n");
    printf("arr[0] : %d\n", arr[0]);
    printf("arr[1] : %d\n", arr[1]);
    printf("arr[2] : %d\n", arr[2]);

    return 0;
}

  <포인터를 이용해서 배열 내부값 조작 - 방법 2>

선언한 포인터가 배열의 첫번째 칸을 가리키면, 포인터도 마치 배열처럼 쓸 수 있다.

#include <stdio.h>

int main()
{
    int arr[3] = { 0, 1, 2 };
    // 배열 초기값 출력 해보기
    printf("arr[0] : %d\n", arr[0]);
    printf("arr[1] : %d\n", arr[1]);
    printf("arr[2] : %d\n", arr[2]);


    // 배열을 조작할 포인터 선언, arr[0] 첫번째 주소를 가리킴.
    int* ptr = &arr[0];

    // 첫번째 값 바꾸기
    ptr[0] = 50;
    // 두번째 값 바꾸기, 자료형이 int이므로 1씩 증가하면 4byte씩 뒤로 이동.
    ptr[1] = 70;
    // 세번쨰 값 바꾸기
    ptr[2] = 100;

    // 배열 출력해보기
    printf("변경 후 배열 출력\n");
    printf("arr[0] : %d\n", arr[0]);
    printf("arr[1] : %d\n", arr[1]);
    printf("arr[2] : %d\n", arr[2]);

    return 0;
}

C언어 문자열에 관한 배열, 포인터 선언 차이는 아래 참고.

https://ansan-survivor.tistory.com/1251

포인터를 배우기전 대부분 C언어 타입과 변수 선언에 대해서 배우게 된다.

그리고 연산을 위해 초기값을 0으로 선언하기도 한다.

(포인터 에 관해서 아래 참고)

https://ansan-survivor.tistory.com/1237 

하지만 포인터의 초기값 선언은 매우 중요하고, 잘못하면 PC 또는 하드웨어에 큰 영향을 미친다.

보통 포인터 변수의 선언은 아래와 같이 한다.

int * ptr;

그러나 위와 같이 변수 선언하면 컴퓨터는 메모리 어딘가에 저장하여 쓰레기값이 출력된다.

컴파일러 마다 다른데, 비주얼스튜디오 같은경우는 애초에 경고로 초기값을 선언하라고 친절하게 알려준다.

쓰레기 값은 메모리상의 아무 주소나 가리키게 되는데, 아래와 같이 PC를 구동하데 핵심적인 역할을 하는 OS나 핵심프로그램의 영역에 들어가서 메모리 값을 바꿔버리면 PC의 구동에 큰 영향을 미치게 된다.

그러나 옛날엔 큰 문제였지만, 다행이도 최근 컴퓨터나 OS들은 이를 방지하기 위해 다양한 접근 제한등의 조치가 취해져있다.

하지만 임베디드 시스템과 같은 작은 규모의 환경에서는 이러한 선언은 위험하므로 포인터설정의 초기화를 잘 지정해야 한다.

그래서! 결론은 포인터를 처음 선언할 때는 아래와 같이 한다.

그래야 선언한 포인터변수가 아무곳도 가리키지 않기 때문에 나중에 필요한 부분을 가리키게 만들어서 사용할 수 있다.

(안전한 코드)

int * ptr = NULL;

int * ptr = 0;