` Ⅶ. 포인터 < 포인터 변수의 정의 > 포인터는 주소를 나타내는 데이터 유형이다. 다시 말해서 포인터 데이터 유형의 값은 주소라는 얘기가 되며, 이 주소로 역시 숫자를 사용하고 있다. 단지 주소에는 음수가 있을 수 없기 때문에 포인터 데이터 유형의 주소는 양의 정수가 되며 외관상으로 unsigned 데이터 유형과 같게 된다. 다음은 포인터 변수를 정의한 몇 가지 예이다. ┌────────────────────────────────────────────┐ │ ⑴ int *ip; │ │ ⑵ char *cp; │ │ ⑶ int *ip, *jp; │ │ ⑷ int *ip, jp; │ │ │ └────────────────────────────────────────────┘ 지금까지의 변수 정의와 다른것은 변수 앞에 '*'가 있는 것인데, '*'는 뒤의 변수가 포인터 유형 의 변수임을 나타내는 역할을 한다. 위에서 ⑴은 int 유형의 데이터가 기억되어 있는 주기억 장치 의 주소를 값으로 갖는 포인터 변수 ip를 정의한 것이고, ⑵는 포인터 변수 cp를 정의한 것으로 이 주소에는 char 유형의 데이터가 있음을 의미한다. ⑶은 같은 데이터 유형의 포인터 변수들을 한번에 같이 정의한 것으로, 이때 각 포인터 변수 앞에 '*'를 붙여야 한다. 그러나 ⑷와 같이 정 의할 경우 ip는 포인터 변수이지만 jp는 그냥 int 유형의 변수가 되므로 주의해야 한다. 실제로 위의 변수들은 주소를 값으로 갖는다는 점에서는 같다. 그러나 그 주소에 어떤 데이터가 있느냐가 다르기 때문에 ip의 값을 cp에 할당할 수 없으며, 마찬가지로 cp의 값을 ip에 할당할 수 없다. ※ far 포인터 변수와 near 포인터 변수, 그리고 huge 포인터 변수 IBM-PC의 주소는 2가지가 존재하는데, 우선 가장 많이 사용되는 near 포인터의 경우에는 오프셋 값만 주소로 갖게 된다. 이 경우 세그먼트 주소는 고정되어 있음을 의미한다. 따라서 near 포인 터 변수의 크기는 16비트가 되며 현재 고정된 세그먼트 주소로부터 64K 바이트 이내의 값만 주소 로 갖게 된다. 반면에 far 포인터 변수는 세그먼트 주소와 오프셋을 각각 16비트씩 값으로 갖는 다. 따라서 far 포인터 변수는 32비트의 크기를 갖게 되며 주기억 장치의 어느 곳이나 주소를 값 으로 가질 수 있다. huge 포인터는 far 포인터와 유사하나 오프셋의 값이 항상 0에서 15사이의 값을 갖도록 만든 것이 다르다. 이 주소를 사용하면 주기억 장치의 한 장소 중에서 주소가 딱 하 나로 결정되는 장점이 있다. 포인터를 far 또는 near, huge로 선언하고자 할 때에는 다음과 같이 변수 이름과 데이터 유형 사이에 키워드를 집어 넣으면 된다. ┌────────────────────────────────────────────┐ │ int near *ip; /* 포인터 앞에 아무것도 없을 경우에는 사용하는 */ │ │ char far *cp; /* 메모리 모델에 의해 near, far, huge 등이 결정된다 */ │ │ float huge *fp; │ │ │ └────────────────────────────────────────────┘ 많이 사용하는 small 메모리 모델의 경우에는 모두 near 포인터가 되며 large 메모리 모델의 경 우에는 모두 far 포인터가 된다. ※ IBM-PC에서의 주소 세그먼트 주소 : 주기억 장치를 16개의 바이트로 나눈 것으로, 이 나눈 것에 주소를 붙인 것이 세그먼트 주소이다. IBM-PC의 주소의 크기가 20비트이기 때문에, 이는 1M 바이트가 되며 이를 16 바이트로 나누게 되면 65536 = 216개의 세그먼트가 존재하게 된다. 따라서 세그먼트 주소의 크기 는 16비트가 된다. 오프셋 : 한 세그먼트 내의 바이트의 위치를 나타낸다. 한 세그먼트의 크기가 16바이트이므로 이의 위치는 0에서 15까지의 수로, 즉 4비트 크기의 주소로 나타낼 수 있다. 따라서 세그먼트 주 소와 오프셋을 합하면 바로 한 바이트를 나타내는 주소가 된다. 그런데 IBM-PC에서는 특이하게도 오프셋을 16비트로 표현하고 있다. 따라서 세그먼트의 주소가 1000(16)이고 오프셋이 2343(16)인 경 우 이것이 나타내는 바이트의 주소는 다음과 같다. ┌────────────────────────────────────────────┐ │ 10000(16) + 2343(16) = 12343(16) │ └────────────────────────────────────────────┘ 위와 같이 바이트를 서로 다른 여러 개의 세그먼트 주소와 오프셋의 조합으로 나타낼 수 있음을 알 수 있다. 일반적으로 세그먼트 주소는 고정시켜 놓고 오프셋만 주소로 사용하는데, 이 경우 오프셋의 주소가 16비트이므로 최고 64K 바이트의 주기억 장치까지만 사용할 수 있다. < '&' 연산자 > 포인터 유형의 변수는 주소를 값으로 가지기 때문에 이를 사용하려면 주소를 할당하여야 하는데 C에서는 이를 위해 '&' 연산자를 제공하고 있다. 이는 다음과 같은 형태로 사용한다. ┌────────────────────────────────────────────┐ │ &변수이름 │ └────────────────────────────────────────────┘ 계산 결과는 바로 뒤의 변수의 현재 주소가 된다(이 주소도 역시 메모리 모델에 따라 near 주소 가 되거나 far, huge 주소가 되며, 특정 주소로 변경하려면 (int far *)와 같이 형 변환 연산자를 사용하면 된다). 주소는 양의 정수이기 때문에 & 연산자의 계산 결과는 양의 정수값이 된다. 따 라서 이 값을 %u나 %lu를 사용하여 출력시키면 변수의 주소를 출력할 수 있다. int i; char c; float f; double d; static int si; static char sc; static float sf; static double sd; main() { int mi; char mc; float mf; double md; printf("Address of i = %u\n",&i); printf("Address of c = %u\n",&c); printf("Address of f = %u\n",&f); printf("Address of d = %u\n",&d); printf("Address of si = %u\n",&si); printf("Address of sc = %u\n",&sc); printf("Address of sf = %u\n",&sf); printf("Address of sd = %u\n",&sd); printf("Address of mi = %u\n",&mi); printf("Address of mc = %u\n",&mc); printf("Address of mf = %u\n",&mf); printf("Address of md = %u\n",&md); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- Address of i = 2017 Address of c = 2004 Address of f = 2013 Address of d = 2005 Address of si = 2032 Address of sc = 2019 Address of sf = 2028 Address of sd = 2020 Address of mi = 65476 Address of mc = 65479 Address of mf = 65480 Address of md = 65484 auto 메모리 유형의 변수들과 extern, static 메모리 유형의 변수들의 주소가 크게 차이가 남을 볼 수 있는데, auto 유형의 변수들은 스택(stack)이라고 불리는 메모리 영역에 할당된다. 스택은 프로그램이 수행됨에 따라 그 크기가 가변적으로 변하는데, auto 유형의 변수들도 이에 맞추어 자신이 선언된 함수나 블럭에 있을 때에는 스택에 존재하고 그 외의 경우에는 없어지게 된다. 반 면에 extern과 static 유형의 변수들은 힙(heap)이라고 불리는 영역에 할당된다. 이는 별도로 존재 하기 때문에 존속 기간이 전체 프로그램의 수행 시간과 같다. '&' 연산자는 위와 같이 변수의 주소를 계산하기 위해서 있는 것은 아니다. 바로 포인터 변수에 주소를 할당할 때 이 '&' 연산자를 사용한다. ┌────────────────────────────────────────────┐ │ int i = 10; │ │ int *ip; │ │ ip = &i; │ │ │ └────────────────────────────────────────────┘ 포인터 변수 ip가 int 유형의 주소를 값으로 갖는 변수이기 때문에 같은 int 유형의 변수인 i의 주소를 할당 받고 있다. 그러나 다음과 같이 할당할 수는 없다. ┌────────────────────────────────────────────┐ │ char c; │ │ int *ip; │ │ ip = &c; │ │ │ └────────────────────────────────────────────┘ c가 int 유형이 아닌 char 유형의 변수이기 때문이다. 포인터의 경우에 같은 유형의 포인터 값이 아니면 컴파일시에 바로 에러가 나게 된다. 그러나 다음과 같이 형 변환을 사용하면 다른 데이터 유형의 주소를 포인터 변수에 할당할 수 있다. ┌────────────────────────────────────────────┐ │ char c; │ │ int *ip; │ │ ip = (int *)&c; │ │ │ └────────────────────────────────────────────┘ 또 '&' 연산자를 사용하면 포인터 유형의 변수들에게 다음과 같이 초기값을 줄 수 있다. ┌────────────────────────────────────────────┐ │ int i = 10; │ │ int *ip = &i; │ │ char c = 'A'; │ │ char *cp = &c; │ │ │ └────────────────────────────────────────────┘ '&' 연산자는 변수 이외의 것에는 사용할 수 없으며, 따라서 다음과 같이 사용할 수 없다. ┌────────────────────────────────────────────┐ │ ⑴ &3 /* 3은 변수가 아니라 상수이다 */ │ │ ⑵ &(x+y) /* x+y는 변수가 아니라 수식이다 */ │ │ ⑶ &&x /* &(&x)가 되어 &(주소)가 되는데, 주소는 변수가 아니다 */ │ │ ⑷ register int x; /* register 유형의 변수는 주기억 장치가 아닌 레지스터에 */ │ │ &x; /* 할당되기 때문에 주소라는 것이 있을 수가 없다 */ │ │ │ │ │ └────────────────────────────────────────────┘ ※ 포인터 변수에 바로 주소를 할당 주소는 양의 정수이기 때문에 다음과 같이 직접 주소를 할당하는 것이 실제로 가능하다 ┌────────────────────────────────────────────┐ │ int *ip = (int *) 2000; /* 반드시 형 변환 연산자를 사용하여야 한다 */ │ └────────────────────────────────────────────┘ 위와 같이 직접 주소를 할당하였을 때에는 당연히 그 주소에 해당 데이터 유형의 데이터가 있어 야 한다. 예를 들어 위의 경우에 2000번지에 int 유형의 데이터가 있어야 한다. 그렇지 않은 경 우에는 위의 포인터를 사용할 때 에러가 발생하게 된다. PC의 경우에는 주소가 고정되어 있는 경우가 많기 때문에 위와 같이 주소를 직접 지정해 주는 것이 의미가 있는데, 특히 비디오 메모리를 액세스할 때에는 직접 주소를 할당하는 것이 더 효율 적인 경우가 많다. ※ NULL 포인터 포인터가 가질 수 있는 값 중에 NULL이란 것이 있는데, 먼저 #include 를 선언해야만 사용할 수 있다. 이는 실제로 0의 값인데 포인터 변수가 이 값을 갖게 되면 0번지를 값으로 갖는 것이 아니라 아직 값이 없는 것이 된다. 따라서 포인터 변수에 초기값을 주고 싶을 때에는 이 NULL을 다음과 같이 주면 된다. ┌────────────────────────────────────────────┐ │ #include │ │ char *cp = NULL; │ │ : │ │ │ └────────────────────────────────────────────┘ < '*' 연산자 > 포인터 변수를 사용하는 목적은 그 변수가 값으로 갖고 있는 주소의 데이터를 사용하기 위해서 이다. 포인터 변수가 값으로 갖고 있는 주소의 데이터를 사용하고자 할 때에는 '*'를 사용하면 되 는데, 다음과 같은 형태로 사용한다. ┌────────────────────────────────────────────┐ │ int i = 100, j; │ │ int *ip = &i; │ │ j = *ip; │ │ │ └────────────────────────────────────────────┘ ip가 i의 주소를 값으로 갖고 있기 때문에 *ip는 ip가 갖고 있는 주소의 값, 즉 i의 값이 된다. 따 라서 j는 i의 값인 100을 갖게 되며 결국 j = *ip; 는 j = i; 와 같은 의미를 갖게 된다. 또 다음의 경우를 보면 ┌────────────────────────────────────────────┐ │ int i = 10, j; │ │ int *ip = &i, *jp; │ │ jp = ip; │ │ j = *jp + *ip; │ │ │ └────────────────────────────────────────────┘ ip가 i의 주소를 갖고 있는데 ip의 값을 jp에 할당했으므로 jp도 i의 주소를 갖고 있게 된다. 따라 서 *ip와 *jp는 모두 i가 되며 따라서 위의 j = *jp + *ip는 j = i + i가 되어 j의 값은 20이 된다. 위에서는 ip와 jp 둘 다 int 유형의 데이터의 주소를 갖는 포인터였기 때문에 jp = ip와 같이 값 을 그대로 할당할 수 있었지만 만약 서로 다른 데이터 유형의 주소를 값으로 갖는 포인터 였다면 이와 같이 할당할 수는 없고 다음과 같이 형 변환 연산자를 사용해야만 한다. ┌────────────────────────────────────────────┐ │ int i = 10, *ip = &i; │ │ char c = 'A', *cp = &c; │ │ cp = (char *)ip; │ │ │ └────────────────────────────────────────────┘ 그러나 위와 같이 했다고 해서 cp의 값과 ip의 값이 다른 것은 아니다. 둘 다 변수 i의 주소를 값으로 갖게 되는데 '*' 연산자를 사용할 때 차이가 발생한다. 즉 *ip의 경우에는 주소에 int 유형 의 데이터가 있다고 간주하여 그 주소로부터 2바이트의 값을 가져 오는 반면 *cp의 경우에는 주 소에 char 유형의 데이터가 있다고 간주하여 그 주소로부터 1바이트의 값만 갖고 오게 된다. 다음에 나오는 두 프로그램은 이를 잘 나타내고 있다. main() { int i; /* int형 변수의 내용은 필요로한 int값을 저장할 수 있고 */ int *iptr; /* int형 포인터 변수의 내용은 int형 변수의 번지수를 저장 할 수 있다 */ i = 256; /* 256 == 0x100 */ iptr = &i; printf("%d\n",*iptr); /* *iptr은 iptr이 가리키고 있는 메모리의 내용 */ } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- 256 main() { int i; char *iptr; i = 256; iptr = (char *)&i; /* 형 변환 연산자를 사용하지 않으면 경고 메시지가 출력된다 */ printf("%d\n",*iptr); /* iptr이 char형이기 때문에 1바이트만을 참조한다 */ } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- 0 위 프로그램의 메모리 상태를 그림으로 보면 다음과 같다. +----+ 30AB | 00 |---+------- 변수 i가 만들어진 장소 (내용이 들어있는 상태를 보면 앞뒤가 +----+ | 바뀌어서 들었음을 볼 수 있는데 이것은 IBM-PC의 특성상 그러한 30AC | 01 |---+ 방법으로 데이터가 들어가게 된다) ------+----+----- 30AD | AB |---+------- 포인터 변수 iptr이 만들어진 장소 +----+ | (iptr이 int형일 때 30AB부터 30AC까지 2바이트를 참조하는 반면 30AE | 30 |---+ iptr이 char형이기 때문에 30AB번지의 1바이트 만을 참조한다. ------+----+----- 그렇기 때문에 결과는 0이 된다) 이처럼 메모리를 차지하는 데는 포인터의 형이 영향을 미치지 못하지만 메모리를 참조하는 데는 커다란 차이가 있다. 이상의 결과를 다시한번 정리하면 다음과 같다. ┌────────────────────────────────────────────┐ │ int *iptr; 이라고 정의했을 때 │ │ iptr : 다른 int형 변수의 번지를 저장한다. │ │ printf("%p",iptr); │ │ ☞ iptr이 가지고 있는 번지(i의 주소)가 화면에 표시된다. │ │ *iptr : iptr이 가리키고 있는 번지의 내용에 해당된다. 즉 *iptr과 i는 같은 것이 │ │ 되는데 iptr이 i를 가리킬 때, *iptr은 i의 (alias : 별명)다른 명칭이라 한다. │ │ printf("%d",*iptr); │ │ │ │ int i; 라고 정의했을 때 │ │ i : 메모리상에 정수값을 저장할 장소를 만든다. │ │ &i : i가 만들어진 메모리상의 번지를 의미한다. │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ '*' 연산자의 계산 결과는 그 주소의 값이지만, 그 주소의 변수와 똑같이 사용할 수 있다는 것이 다. 즉 반드시 변수가 와야 하는 곳에 '*' 연산자가 붙은 수식이 올 수도 있다. 예를 들면 다음과 같다. ┌────────────────────────────────────────────┐ │ int i = 10, *ip = &i; │ │ *ip = 100; │ │ ++*ip; │ │ ip = &*ip; │ │ │ └────────────────────────────────────────────┘ '='의 왼쪽이나 ++ 연산자와 & 연산자의 인자에는 반드시 변수가 와야 하는데, 위에서는 '*' 연 산자가 오고 있다. '*' 연산자는 그것이 주소를 갖고 있는 변수 자체를 의미하기 때문에 이것이 가능하게 된다. ip가 i의 주소를 값으로 갖고 있기 때문에 *ip는 바로 i가 된다. 따라서 *ip = 100은 i = 100과 같으며 i의 값이 100으로 변하게 된다. 결국 i 변수 자체를 사용하지 않고 다른 방법에 의해 i의 값을 변경한 것이 된다. 마찬가지로 ++*ip는 ++i와 같기 때문에 i의 값이 1증가하여 101이 된다. 마지막의 ip = &*ip는 *ip가 i이므로 ip = &i가 되어 결국 자신의 값을 그대로 유지하게 된다. 하나 더 주의할 것은 ++*ip와 *ip++가 다르다는 것이다. ++와 '*'는 우선 순위가 같으나 결합방 향이 오른쪽에서 왼쪽이기 때문에 ++*ip는 ++(*ip)로 처리되어 결국 ++i가 되지만 *ip++의 경우에 는 *(ip++)로 처리된다. 이때 ip뒤에 ++가 붙었기 때문에 이는 나중에 계산되므로 *ip가 되고 이 를 계산한 후(이는 i이다) ip++에 의해 ip의 값을 증가하게 된다. 따라서 이 경우 i의 값은 변하지 않고 오히려 ip의 값이 변하게 된다. 만약 *ip에 대해 ++를 뒤에 적용하고 싶으면 (*ip)++와 같이 괄호를 사용하면 된다. < 포인터를 이용한 참조에 의한 호출 > C에서는 모든 것을 값에 의한 호출 형태로 인자를 전달하고 있다. 값만 넘어가기 때문에 받은 쪽에서는 부른 쪽의 데이터를 변경할 수 없게 된다. 반면에 참조에 의한 호출의 경우에는 변수 자체가 넘어가기 때문에 받은 쪽에서 부른 쪽의 데이터를 변경할 수 있게 되는데 C에서는 참조 에 의한 호출을 전혀 지원하지 않기 때문에 이를 기본적으로는 할 수 없지만 포인터를 사용하면 이와 같은 효과를 낼 수 있다. 즉 실인자에 값을 주는 것이 아니라 변수가 할당되어 있는 번지를 건내주므로써 간접적인 참조에 의한 호출을 행한다. 다음이 그 프로그램이다. main() { void swap(int *, int *); int i = 10, j = 20; printf("i = %d, j = %d\n",i,j); swap(&i,&j); /* & 연산자를 사용하여 주소를 넘겨주고 있다 */ printf("i = %d, j = %d\n",i,j); } void swap(int *ip, int *jp) { /* 받는 쪽은 주소를 받아야 하므로 포인터가 된다 */ int t; t = *ip; *ip = *jp; *jp = t; } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- i = 10, j = 20 i = 20, j = 10 결과적으로 변수 i와 j를 넘겨준 참조에 의한 호출과 같은 결과를 낳게 되었다. 그러나 실제로 참조에 의한 호출로 인자가 전달된 것은 아니다. 역시 값만 넘어 갔는데 그 값이 바로 주소였기 때문에 swap에서 main의 변수를 사용할 수 있었던 것이다. 즉 어떤 변수를 참조에 의한 호출로 전달하고자 할 때에는 부르는 쪽에서는 그 변수의 주소를 넘겨주고, 받는 쪽에서는 이에 대한 포 인터 변수로 받으면 된다. 그러면 받는 쪽에서 부르는 쪽의 변수를 마음대로 사용할 수가 있게 된다. 다음은 이의 몇 가지 예이다. #include read_number(long int *res) { /* 하나의 정수를 읽음 */ int base = 10; /* 기본 진법은 10 */ int sign = 1; /* 기본 부호는 + */ char c; void skip_last(void); /* 함수 선언 */ *res = 0l; again: while ((c = getchar()) == ' ' || c == '\t'); /* 처음 와 은 무시 */ switch (c) { case 'd': break; /* d로 시작하면 10진수 */ case 'b': base = 2; /* b로 시작하면 2진수 */ break; case 'o': base = 8; /* o로 시작하면 8진수 */ break; case 'x': base = 16; /* x로 시작하면 16진수 */ break; case '+': goto again; /* +면 부호에 변화가 없음 */ case '-': sign *= -1; /* -면 부호가 정반대로 */ goto again; case EOF: return (EOF); default : ungetc(c,stdin); /* 하나 더 읽을 것을 다음에 읽기 위해 보관 */ } while ((c = getchar()) != EOF && (((base != 16) && (c >= '0') && (c - '0' <= base - 1)) || ((base == 16) && ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))))) /* 읽은 문자가 진법에 맞는 동안 */ switch (c) { case 'a': /* 16진수의 A */ case 'A': *res = *res * base + 10l; break; case 'b': /* 16진수의 B */ case 'B': *res = *res * base + 11l; break; case 'c': /* 16진수의 C */ case 'C': *res = *res * base + 12l; break; case 'd': /* 16진수의 D */ case 'D': *res = *res * base + 13l; break; case 'e': /* 16진수의 E */ case 'E': *res = *res * base + 14l; break; case 'f': /* 16진수의 F */ case 'F': *res = *res * base + 15l; break; default : *res = *res * base + c - '0'; /* 읽어 들인 문자를 숫자로 변환 */ } if (c == EOF) /* 화일의 끝이면 할 것이 없음 */ return (EOF); if (c == ' ' || c == '\t') /* 나머지 와 을 무시 */ skip_last(); if (c == '\n' || c == ' ' || c == '\t') { *res *= sign; /* 지금까지의 결과에 부호를 곱함 */ return (1); } return (0); /* 그렇지 않으면 에러 */ } void skip_last() { /* '\n'이 나올 때까지 읽어 버리는 함수 */ while (getchar() != '\n'); } main() { long int i; long int sum = 0; int status; while ((status = read_number(&i)) != EOF) { /* 입력의 끝까지 숫자를 읽어 */ if (status == 0) { printf("Input error!!\n"); return (1); } sum += i; /* 합을 구함 */ } printf("The sum is %ld.\n",sum); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- b11000111 뇌 o234567 뇌 xabcdef 뇌 2525 뇌 ^Z 뇌 The sum is 11342346. main() { int x, y, z; void swap(int *, int *); printf("Input three numbers -> "); scanf("%d%d%d",&x,&y,&z); /* scanf는 참조에 의한 호출로 변수를 받는다 scanf에서 x,y,z의 값을 변경할 수 있어야 하기 때문이다 */ if (x > y) swap(&x,&y); if (x > z) swap(&x,&z); if (y > z) swap(&y,&z); printf("Sorted result : %d %d %d\n",x,y,z); } void swap(int *ip, int *jp) { int t; t = *ip; *ip = *jp; *jp = t; } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- Input three number -> 250 72 128 뇌 Sorted result : 72 128 250 < 포인터 연산 > 포인터 변수는 int형일 수도 있고, char형일 수도 있고 float형 일수도 있다. 하지만 그것에 무관 하게 메모리에서 차지하는 양은 단지 2바이트만을 차지한다. ┌────────────────────────────────────────────┐ │ char *cptr; → char형 포인터 │ │ int *iptr; → int형 포인터 │ │ float *fptr; → float형 포인터 │ │ │ │ ------+-----+------ │ │ 30AB | | -+ │ │ +-----+ +------ cptr이 차지하는 메모리 │ │ 30AC | | -+ │ │ ------+-----+------ │ │ 30AD | | -+ │ │ +-----+ +------ iptr이 차지하는 메모리 │ │ 30AE | | -+ │ │ ------+-----+------ │ │ 30AF | | -+ │ │ +-----+ +------ fptr이 차지하는 메모리 │ │ 30B0 | | -+ │ │ ------+-----+------ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 메모리에서 차지하는 양을 보면 포인터의 형과는 무관하게 단지 2바이트만을 차지하지만 포인터 변수 앞에 정의한 형은 상당히 중요한 역할을 한다. 가리키고 있는 메모리가 int형인지, char형인 지를 판단하게 해주는 역할을 한다. 예를 들어보면 void main(void) { int i, *iptr; i = 5; iptr = &i; printf("iptr = %p\n",iptr); iptr++; printf("iptr = %p\n",iptr); iptr = iptr + 2; printf("iptr = %p\n",iptr); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- iptr = FFD2 iptr = FFD4 iptr = FFD8 포인터의 증감은 그 형의 크기에 따라 증가 또는 감소한다. 즉 int형 포인터 변수를 1증가하면 실제 번지수 값은 2가 증가되며 float형은 4가, char형은 1이 증가됨을 알 수 있다. 즉 숫자적인 덧셈이 아니라 다음 몇 번째란 의미를 갖는데, 실제로 주소는 그 포인터의 데이터 유형의 크기만 큼 증가하게 된다. 다음의 그림은 이를 나타내고 있다. data *p; 주소 +------------+ p -----------------→ | data0 | N +------------+ p + 1 -------------→ | data1 | N + 1 * sizeof(data) +------------+ p + 2 -------------→ | data2 | N + 2 * sizeof(data) +------------+ p + 3 -------------→ | data3 | N + 3 * sizeof(data) +------------+ 마찬 가지로 포인터 변수에서 어떤 값을 빼게 되면 그 값 만큼 이전 데이터를 의미하게 된다. data *p; 주소 +------------+ p - 3 -------------→ | data-3 | N - 3 * sizeof(data) +------------+ p - 2 -------------→ | data-2 | N - 2 * sizeof(data) +------------+ p - 1 -------------→ | data-1 | N - 1 * sizeof(data) +------------+ p -----------------→ | data0 | N +------------+ 하나 더 사용할 수 있는 것이 있는데 이는 같은 데이터 유형의 포인터들 사이의 뺄셈이다. ┌────────────────────────────────────────────┐ │ int *ip = (int *) 1000, *jp = (int *) 1200; │ │ printf("jp - ip = %d\n",jp - ip); │ └────────────────────────────────────────────┘ 위의 경우는 1000번지와 1200번지 사이에 int 유형의 데이터들이 죽 들어 있다고 가정하여 jp의 데이터와 ip의 데이터 사이가 순서로 몇 번째 차이 인지를 의미하는 것으로 이는 두 포인터 변수 의 값을 뺀 후 이를 int 유형의 크기로 나누면 된다. 따라서 jp - ip는 (jp - ip) / sizeof(data)와 같은 의미를 갖게 되며 다음과 같은 출력을 내게 된다. ┌────────────────────────────────────────────┐ │ jp - ip = 100 (MSC, TC) │ └────────────────────────────────────────────┘ 이외의 다른 연산자나 수식은 모두 사용할 수 없고, 사용하면 컴파일시 에러가 발생하게 된다. 다음은 포인터 연산에서 사용할 수 없는 것들이다. ┌────────────────────────────────────────────┐ │ int *ip, *jp; │ │ char *cp; │ │ ⑴ ip + jp /* 두 포인터 간에 덧셈은 할 수 없다 */ │ │ ⑵ ip * 2 /* 포인터 변수에 곱셈을 하게 되면 컴파일시 에러가 발생한다 */ │ │ ⑶ jp / 3 /* 사용할 수 없는 연산자를 사용했다 */ │ │ ⑷ ip + 3.2 /* 정수값만 더해야 하는데 실수값(3.2)을 더했다 */ │ │ ⑸ ip - cp /* 같은 데이터 유형의 포인터들 사이에만 뺄셈을 할 수 있다 │ │ (이 경우 어느 한 쪽을 형 변환하면 사용할 수 있다) */ │ │ │ │ │ │ │ └────────────────────────────────────────────┘ 다음은 포인터 연산에 관한 프로그램이다. main() { int i = 10, *ip = &i; int j, k; char c = 'D', *cp = &c; double *jp = (double *) 2000; *ip++ = ++i; ++*--ip; ++*cp++; *--cp = c + 3; jp += 5; j = jp - (double *) 80; k = (int)(jp - 80); printf("i = %d, j = %d, k = %d, c = %c\n",i,j,k,c); } ┌───┐ │ 결과 │ └───┘ --------------------------------------------------------------------------------- i = 12, j = 245, k = 1400, c = H 우선 *ip++ = ++i의 경우 i의 값을 1 증가시키고(i = 11이 된다) 이를 *ip에 할당하고(*ip는 i이 므로 i = 11) ip가 sizeof(int) 만큼 증가된다. 그 다음 ++*--ip;에서 --ip를 먼저 계산하므로 ip는 도로 원래의 값이 되며 따라서 *ip는 i가 되고 이를 1 증가하므로 i = 12가 된다. ++*cp++는 *cp 와 cp가 1 증가하므로(sizeof(char)는 1이다) c는 'E'가 되고 cp는 1증가한다. 그 다음 *--cp = c + 3에서 c + 3은 'E' + 3이 되며 *--cp에서 --cp로 다시 cp가 c의 주소를 가지므로 *--cp는 c가 된다. 따라서 c는 'E' + 3 = 'H'를 갖게 된다. 그리고 jp += 5에서 jp가 2000을 값으로 가지므로 jp = 2000 + sizeof(double) * 5가 되어 2040 이 되며, 그 다음 j = jp - (double *) 80에서 80이 주소로 형 변환 되었으므로 포인터 사이의 뺄 셈이 되어 (2040 - 80) / sizeof(double)이 되므로 j는 245가 된다. 마지막으로 k = (int)(jp - 80)의 경우 jp - 80에서 80이 주소가 아닌 정수이므로 jp - 80 * sizeof(double)이 되어 2040 - 80 * 8 = 1400이 되므로 k는 1400이 된다.