1차원 배열의 포인터

 
#include

// 1차원 배열
void main(void) {
	int a[4] = { 10, 20, 30, 40 };

	// 주소는 1000으로 가정

	printf("%d\n", a[0]);		// 10
	printf("%#.8x\n", &a[0]);	// 0x1000
	printf("%#.8x\n", a);		// 0x1000 
	printf("%d\n", a[0] + 1);	// 11
	printf("%#.8x\n", a + 1);	// 0x1004
	printf("%d\n", *a);			// 10
	printf("%d\n", *(a + 1));	// 20
	printf("%#.8x\n", &a);		// 0x1000
	printf("%#.8x\n", *&a);		// 0x1000
	printf("%#.8x\n", &a + 1);	// 0x1010
	
	/*
	맨 마지막 &a + 1은 나름 묘한 결과가 나온다.
	1004가 예상되지만, 1010의 결과가 나온다. (주소가 16 증가했음)
	그 이유는 a + 1과는 다르게 (&a) + 1라 생각하면 좀 느낌이 온다.
	a의 타입을 int [4]로 생각하면

	  ㅡㅡㅡ	
	ㅣ ---- ㅣ
	ㅣl 10 lㅣ a	&a
	ㅣ ---- ㅣ
	ㅣl 20 lㅣ a+1
	ㅣ ---- ㅣ
	ㅣl 30 lㅣ a+2
	ㅣ ---- ㅣ
	ㅣl 40 lㅣ a+3
	ㅣ ---- ㅣ
	  ㅡㅡㅡ
	ㅣ	??  ㅣ		&a + 1 -> 요기

	이런 식으로 int [4] 타입을 여러 개 나열해두면 그 다음 쪽을 가리키기 때문..
	int [4] 는 16byte를 차지하기 때문에 &a + 1은 주소가 16이 더해지게 된다.
	*/

	system("pause");
}

추가로 배열은 포인터 타입이 헷갈린다.

int a[4]에서 타입은 다음과 같다

a : int [4] 

a[0] : int

&a[0] : int *

a == &a[0] 이므로 배열명은 배열(int [4]) 이면서 포인터(int *)로 쓰인다.

배열 타입으로 사용 : sizeof(a), &a

포인터 타입으로 사용 : a + 1, *a, func(a)

int [4]의 크기는 16byte, int *의 크기는 4byte(포인터는 가리키는 내용이 char 이든 int [4]이든 모두 크기가 4byte이다.)

배열명 a가 포인터 타입으로 사용되는 경우 타입은 int *이다.

따라서 a + 1은 주소가 4가 증가하게 된다.

그래서 다음과 같은 결과가 발생한다.

a[0] == *a

a[1] == *(a+1)

a[2] == *(a+2)

a[I] == *(a+i)

int a[4] = {1, 2, 3, 4}라면

(a + 1)[2] 는 4

2[a] == a[2] -> 물론 이렇게 쓰면 한대 맞을 수 있다.

같은 경우도 메모리 구조를 생각하면 이끌어낼 수 있다.