『프로그래밍 언어 강좌-C,C++,VC 강좌 (go PROG)』 1588번 제 목:[강좌] 포인터 스터디 [3/8] -신경호 올린이:파이사랑(신경호 ) 00/01/26 23:58 읽음:411 관련자료 없음 ----------------------------------------------------------------------------- 『배움터-강좌 (go SSCS)』 28번 제 목:[강좌] 포인터 스터디 [3/8] -신경호 올린이:파이사랑(신경호 ) 00/01/23 23:35 읽음: 3 관련자료 없음 ----------------------------------------------------------------------------- ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ■ 포인터 스터디 [3] ■ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ [990131 파이사랑] ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ■ 3. 다차원 배열과 포인터 ■ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ◐ 다차원 배열 이제 다차원 배열에 대해 알아보도록 합시다. C에서 배열의 차원은 제한이 없지요. 왜일까요? 바로 포인터를 사용해 구현이 되기 때문입니다. int ia[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } }; 이런 2차원 배열이 있다고 합시다. a[0][0]이 1, a[0][1]이 2, 이렇게 된다 는건 아시겠지요? 그런데 이 이차원 배열 형태는 실제로 내부적으로는 1차원 배열의 1차원 배열 형태입니다. 사실 C에서는 ?차원 배열이란 건 원래 존재하 질 않는다는 거지요. 3차원 배열은 배열의 배열의 배열 형태… 이렇게 말이에 요. 어렵다고요? 나눠서 생각을 해 봅시다. int ia1[3] = { 1, 2, 3 }; int ia2[3] = { 4, 5, 6 }; 이 두개의 요소가 ia[2]의 각 요소라고 생각하면 되겠지요. 다시 말하자면 int[3]을 하나의 타입으로 보면 되는 겁니다. 타입을 새로 정의해서 생각하면 더 쉬울것 같네요. typedef int arrayint[3]; 크기가 3인 int형 배열을 따로 arrayint형으로 정의한 겁니다. 이제 다음과 같이 하면 크기가 2인 arrayint형 배열을 잡을 수 있지요. int의 [2][3] 배열 과 완전히 동일한 거겠고요. arrayint ar[2]; 여기서 배열과 포인터의 또 하나의 차이점을 말씀드리지요. 배열은 그 배열 이름을 사용해 크기를 알아낼 수 있습니다. 포인터는 그럴 수가 없지요. 다음 을 실행해 보세요. (#include는 제외하겠습니다) ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ ┃ void main(void) { ┃ ┃ int ar[5], *p = ar; ┃ ┃ printf("%d %d %d", sizeof(ar), sizeof(p), sizeof(*p)); ┃ ┃ } ┃ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ 결과가 어떤가요? 10 4 2가 나오지요. 그렇습니다. 배열명은 그 타입 자체 int[5]를 대표하고 있기 때문에 크기를 알 수 있지만, p의 경우는 그냥 포인 터이므로 크기는 당연히 4가 되겠고, *p는 int형일테니까 2가 되지요. 그럼 다음은 어떨까요? int ia[2][3]; printf("%d", sizeof(ia[0])); 결과는 6입니다. ia[0]은 사실상 int[3]형이기 때문이지요. ia[1]도 결과는 같을 겁니다. 그러면 sizeof(ia)의 결과를 예상해 보세요. 네. int[2][3]형이 기 때문에 sizeof(int)*2*3인 12가 되겠지요. 어때요? 아시겠나요? 다시 말씀 드리지만 C는 배열의 타입을 정확히 알고 있다는 겁니다. 3차원 배열 이상도 마찬가지 입니다. 물론 좀 복잡하니까 여기서는 다루지 않겠습니다. ◐ 다차원 배열과 포인터 이제부터는 다음의 값을 기준으로 예제를 작성하겠습니다. int ia[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } }; ┏━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ ┃주소┃ 41 42 43 44 45 46 47 48 49 4A 4B 4C ┃ ┃ ┃ ┳━━━┳━━━┳━━━┳━━━┳━━━┳━━━┳━━━━━ ┃ ┃ 값 ┃ ┃01┃00┃02┃00┃03┃00┃04┃00┃05┃00┃06┃00┃ … ┃ ┃ ┃ ╋━━━┻━━━┻━━━╋━━━┻━━━┻━━━╋━━━━━ ┃ ┃이름┃ ┗ia[0] ┻ia[1] ┛ ┃ ┃ ┃ ┗ia ┛ ┃ ┗━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ 위의 그림을 잘 보세요. ia는 포인터 상수라고 말씀드렸지요. 그런데 이 경 우는 주소값만이 아닌 크기도 가지고 있다고 했습니다. 이런 포인터 상수를 배열 상수라고 합니다. 포인터 상수에 크기를 더한 개념이지요. 위 그림에서 ia[0]과 ia[1]도 역시 배열 상수 입니다. 이들이 가리키는 내용은 배열 ia의 구성요소이기 때문에 「부분 배열」이라고도 합니다. 다음 표를 보세요. ┏━━┳━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓ ┃상수┃ ia ┃ ia[0] ┃ ia[1] ┃ ┣━━╋━━━━━━━━━╋━━━━━━━━━━╋━━━━━━━━━━┫ ┃ 값 ┃ 41 ┃ 41 ┃ 47 ┃ ┃크기┃ 12 ┃ 6 ┃ 6 ┃ ┃타입┃ int[2][3] ┃ int[3] ┃ int[3] ┃ ┗━━┻━━━━━━━━━┻━━━━━━━━━━┻━━━━━━━━━━┛ 표를 보니 이해가 가시죠? 이제 ia[1][2]라는 연산이 내부적으로 어떻게 작 동하는지 알아 봅시다. ia[1][2]는 *(*(ia + 1) + 2)와 동일한 코드 입니다. 천천히 살펴보지요. ia + 1의 결과는 무엇이 될까요? 47 입니다. ia의 크기 는 12라고 했는데 왜 47이냐고요? 여기서 더해지는 크기는 ia의 크기가 아닌 ia의 배열요소의 크기이지요. 생각해 보세요. int a[4] 일때 a + 1은 a의 크기인 8이 더해지는 것이 아니 라 a의 배열요소의 크기인 int형 크기 2가 더해지잖아요. 다시 돌아가서 생각해 봅시다. ia의 배열요소는 ia[0]과 ia[1]이겠지요. 이 들의 크기는 표에 있다시피 int[3]이므로 6 입니다. 당연히 결과는 47이 되겠 지요. 그리고나서 *연산자를 사용해 값을 읽습니다. 바로 이때 읽혀오는 값은 무엇일까요? 47번지부터 6만큼의 내용입니다. 바 로 ia[1]이지요. 말씀드렸듯이 ia[1] 자체도 배열 상수 입니다. 배열을 가리 키고 있기 때문이지요. 이렇게 읽혀온 ia[1]은 역시 표에 있듯이 값이 47이고 크기가 6인 배열 상수이지요. 이제부터의 계산은 바로 이 ia[1]이 가리키는 { 4, 5, 6 }만을 가지고 행하 면 됩니다. ia[1]=*(ia + 1)={ 4, 5, 6 } 이라는 거지요. 배열 상수 ia[1]에 다시 2를 더합니다. 이때 실제로 더해지는 주소 값은 sizeof(int)*2인 4이겠 지요. 결과적으로 *(ia + 1) + 2는 4B가 되는 겁니다. 다시 *연산자를 사용해 값을 읽어오니까 최종 결과는 6이 되는 거지요. ia[1][2]와 동일한 결과지요? 어때요? 꽤 복잡하네요. 2회까지의 내용을 다 이해하면 담부턴 쉽다고 했는데, 너무 어려웠나요? (그럴수도 있죠 머… ^^) ◐ 다차원 포인터 연산 다음 여러개의 코드가 동일하다는 것만 말씀드리고 넘어가지요. ia[1][2] = *(*(ia + 1) + 2) = *(ia[1] + 2) = (*(ia + 1))[2] = 1[ia][2] = 2[1[ia]] 어렵죠? 물론 프로그래밍 상에서 이렇게 쓰는 경우는 없습니다. 이렇게 쓰 다가는… ==; 포인터 연산의 이해를 위해서 알아본 것 뿐이지요. 한번 이해만 해 보세요. ◐ 다차원 배열의 포인터 int *ip = ia; 위와 같은 코드를 작성했다고 합시다. 컴파일이 될까요? 컴파일 옵션에 따 라서 될수도 있고 안 될수도 있지만 된다고 해도 문제가 생깁니다. ia는 배열 상수이므로 크기를 갖고 있는데 ip는 포인터 변수이므로 크기를 가지지 못한 다는 것이지요. 결국 ip[1][2]와 같은 방법으로는 접근을 할 수가 없지요. 각 ip[0], ip[1] 등의 크기를 알 방도가 없으니까요. 게다가 ia는 int형의 배열 이 아닌 int[3]의 배열이므로 원래는 대입도 불가능해야 하는 겁니다. 타입이 다르니까요. 다차원 배열의 포인터는 다음과 같이 해 주어야 합니다. int (*ip)[3] = ia; 하나를 제외한 나머지는 모두 크기를 정해 주어야 한다는 겁니다. 이렇게 해 준다면 ip[1][2]와 같이 ia를 사용할 때와 동일한 방법으로 접근이 가능하 게 되는 것이지요. ┏━━━━━━━┓ ip┃▒┃▒┃▒┃▒┣┓ ┗━━━━━━━┛┃ ┏━━━━━━━━━━┛ [ ][0] [ ][1] [ ][2] ┃ [ ][0] [ ][1] [ ][2] ia●━━━┳━━━┳━━━┓ ┗▶●━━━┳━━━┳━━━┓ ┃┃01┃00┃02┃00┃03┃00┃[0][ ] ┃┃01┃00┃02┃00┃03┃00┃[0][ ] ┃┣━━━╋━━━╋━━━┫ ┃┣━━━╋━━━╋━━━┫ ┃┃04┃00┃05┃00┃06┃00┃[1][ ] ┃┃04┃00┃05┃00┃06┃00┃[1][ ] ┗┗━━━┻━━━┻━━━┛ ┃┣━━━╋━━━╋━━━┫ · · · · . · · · · . <다차원 배열> <다차원 배열 포인터> 보시다시피 둘다 가로의 크기는 정해져 있고 똑같습니다. 그러나 ia로는 그 크기를 알 수 있는 반면 ip는 일반 포인터이기 때문에 알 수가 없지요. 그러 면 이런 다차원 배열 포인터를 왜 사용할까요? 물론 여러가지 용도가 있을 수 있겠으나 가장 흔히 사용되는 경우는 바로 함수의 인자로 다차원 배열을 쓰고자 하는 경우입니다. 여러번 말씀드렸지만 배열 상수를 인자로 받을 수는 없다고 했지요. 대신 포인터를 이용해야 합니 다. 다음을 보세요. ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ ┃ #include ┃ ┃ ┃ ┃ void swap(int *ip1, int *ip2) { ┃ ┃ int temp; ┃ ┃ temp = *ip1; ┃ ┃ *ip1 = *ip2; ┃ ┃ *ip2 = temp; ┃ ┃ } ┃ ┃ ┃ ┃ void swaparr(int *ip1, int *ip2) { ┃ ┃ swap(&ip1[0], &ip2[0]); ┃ ┃ swap(&ip1[1], &ip2[1]); ┃ ┃ swap(&ip1[2], &ip2[2]); ┃ ┃ } ┃ ┃ ┃ ┃ void sortarr(int (*ip)[3], int size) { ┃ ┃ int i; ┃ ┃ for (i = 0; i < size - 1; i++) ┃ ┃ if (ip[i][0] > ip[i + 1][0]) swaparr(ip[i], ip[i + 1]); ┃ ┃ } ┃ ┃ ┃ ┃ void printarr(int (*ip)[3], int size) { ┃ ┃ int i; ┃ ┃ for (i = 0; i < size; i++) ┃ ┃ printf("[%d] %d %d %d\n", i, ip[i][0], ip[i][1], ip[i][2]);┃ ┃ } ┃ ┃ ┃ ┃ void main(void) { ┃ ┃ int ia[3][3] = { { 3, 5, 2 }, { 2, 6, 8 }, { 4, 2, 6 } }; ┃ ┃ ┃ ┃ sortarr(ia, 3); ┃ ┃ printarr(ia, 3); ┃ ┃ } ┃ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ 여태까지의 예제 중 가장 긴 예제 같네요. ^^; swap 함수는 다 아시리라 믿 고, swaparr 함수는 일차원 배열(sortarr 함수의 인자인 이차원 배열 포인터 ip의 부분 배열)을 받아 각 요소들을 바꾸어주는 함수이고, sortarr 함수는 [각 배열 요소가 3개의 int값을 가지는 이차원 배열]을 인자로 받아 각 요소 의 첫번째 값을 비교해 정렬을 하는 함수이지요. printarr 함수는 이름대로 출력을 해 주는 함수이고… 결과는 각 부분 배열 { 3, 5, 2 }, { 2, 6, 8 }, { 4, 2, 6 }의 첫번째 요 소의 순서대로 정렬되어 다음과 같이 나오겠지요. [0] 2 6 8 [1] 3 5 2 [2] 4 2 6 이해가 되시나요? 안 되시면 몇번 더 읽어보시고 정 안 되시면 인자로 넘겨 주는 부분만 알아두세요. swaparr 함수와 swap 함수의 인자가 왜 똑같은지 등 에 대해서 의문이 생길지도 모르겠는데… 흠. 아무래도 분석을 좀 하는게 좋을 거 같네요. 일단 배열 ia의 시작 번지 가 50이라고 합시다. 그러면 마지막 요소인 6의 번지는 66이 되겠지요. ia[0] 도 역시 50일테고, ia[1]은 56, ia[2]는 62일 겁니다. sortarr(ia, 3)에서 ia는 50이겠지요. sortarr 함수에서의 ip는 포인터 변 수이므로 따로 메모리 어딘가에 생성이 되겠고 그 값은 50이 됩니다. 그리고 는 루프로 0부터 size-1까지 돌면서 현재 부분 배열의 첫번째 값(ip[i][0])과 다음 부분 배열의 첫번째 값(ip[i + 1][0])을 비교해 앞의 값이 크면 순서가 잘못된 것이므로 swaparr 함수를 부르지요. swaparr 함수로 넘어가는 값은 각 부분 배열의 배열 상수 입니다. 예를 들 어 i가 0인 경우에도 3이 2보다 크므로 swaparr이 불리는데 그 두 인자의 값 은 50과 56이 된다는 거지요. ip와 ia의 값이 같기 때문에 ip[0]과 ip[1]도 각각 ia[0]과 ia[1]과 같으니까요. ip와 ia의 차이는 단지 크기를 알 수 있는 지 없는지의 차이라고 했었지요. 가지고 있는 값은 차이가 없고 똑같이 어떤 주소를 포인트할 수 있는 것이지요. 이렇게 넘어온 50과 56이라는 값이 ip1, ip2라는 포인터 변수에 들어가게 되겠지요. 그리고 swaparr 함수에서는 []연산자를 사용해 각각의 int형 요소 에 접근을 하고 다시 그 주소를 구합니다. 그 부분만 보도록 하지요. swap(&ip1[0], &ip2[0]); ip1은 { 3, 5, 2 }라는 배열을 가리키고 있고, ip2는 { 2, 6, 8 }이라는 배 열을 가리키고 있겠지요. 결과적으로 ip1[0]은 3, ip2[0]은 2일 겁니다. 그리 고 다시 각각의 주소를 구하지요. 실제로 swap 함수에 넘어가는 값은 3과 2의 주소인 50과 56 입니다. 그리고 swap 함수에서는 *연산자를 사용해 두 주소의 값을 서로 바꾸게 되는 거지요. 어렵긴 하지만, 하나씩 차근차근 생각해 보세요. ◐ 포인터 배열 여태까지 배열의 포인터 때문에 머리 아파 죽겠는데, 이젠 또 포인터의 배 열이라니… ==; 하지만 역시 잘 생각해 보면 별게 아닙니다. ==; 포인터도 자료형의 하나이지요. 게다가 크기도 일정하고(4 바이트) 단순히 하나의 값을 가진 변수일 뿐입니다. 그쵸? 그렇기 때문에 역시 배열이 될수도 있는 거지요. 우선 이차원 배열을 보도록 합시다. 다른건 제쳐두고 문자열 배열만을 가지 고 생각해 보도록 하지요. char seoulgu1[10][16]; strcpy(seoulgu1[0], "Kangnam-gu"); strcpy(seoulgu1[1], "Mapo-gu"); strcpy(seoulgu1[2], "Chung-gu"); strcpy(seoulgu1[3], "Kwanak-gu"); strcpy(seoulgu1[4], "Nowon-gu"); strcpy(seoulgu1[5], "Seoungbuk-gu"); strcpy(seoulgu1[6], "Seocho-gu"); strcpy(seoulgu1[7], "Dobong-gu"); strcpy(seoulgu1[8], "Youngdeungpo-gu"); strcpy(seoulgu1[9], "Songpa-gu"); 위의 예에서 seoulgu1라는 배열이 차지하는 메모리는 과연 얼마일까요? 금 방 계산이 되지요? ^^ 바로 160 바이트 입니다. 가장 긴 "영등포구"가 널 문 자까지 포함해서 16자이기 때문에 배열로 잡을려면 이렇게 해야 하는 거지요. 그런데 과연 이것뿐일까요? 아닙니다. 전에도 말씀드렸다시피 문자열의 경우 는 따로 변수에서 사용되지 않아도 이미 메모리에 올라와 있습니다. 그러니까 위의 배열이 들어있는 소스를 컴파일하면 저 문자열들 자체가 실행 파일에 포 함되고 저 배열이 선언되기도 전부터 메모리에 존재한다는 것입니다. 그렇기 때문에 따로 105 바이트의 메모리가 필요하다는 것이지요. 이번에는 포인터의 배열로 생각해 봅시다. 우리가 처음에 문자열 배열에 대 해서 다룰 때 다음과 같이 썼었지요. char *sp = "Love"; 이미 아시겠지만 sp에는 단 5바이트 만이 할당되었습니다. 그쵸? 물론 sp라 는 포인터 변수가 차지하는 4바이트가 따로 있기 때문에 실제로는 9바이트가 사용되었겠지요. 이 경우도 역시 "Love"가 실행 파일에 포함되어 포인터 변수 sp가 선언되기 전부터 메모리에 올라와 있습니다. 그런데 sp는 포인터 변수이 기 때문에 "Love"가 존재하는 메모리의 주소가 직접 대입되기 때문에 위의 예 제처럼 따로 메모리를 할당하지 않는다는 것이지요. char *seoulgu2[10]; seoulgu2[0] = "Kangnam-gu"; seoulgu2[1] = "Mapo-gu"; seoulgu2[2] = "Chung-gu"; seoulgu2[3] = "Kwanak-gu"; seoulgu2[4] = "Nowon-gu"; seoulgu2[5] = "Seoungbuk-gu"; seoulgu2[6] = "Seocho-gu"; seoulgu2[7] = "Dobong-gu"; seoulgu2[8] = "Youngdeungpo-gu"; seoulgu2[9] = "Songpa-gu"; 이 경우는 위의 문자열들이 실제로 차지한 105바이트에 문자열 포인터 10개 인 40바이트만 더하면 위의 예제가 사용한 총 메모리 크기가 계산된다는 것이 지요. 훨씬 효율적인 것을 알 수 있습니다. 여기서 한가지 주의할 점이 있습니다. 다음과 같은 코드가 있다고 합시다. char seoulgu1[10][16], *seoulgu2[10]; strcpy( ... ); ... seoulgu2 = seoulgu1; 초기화가 모두 된 이차원 배열인 seoulgu1를 일차원 배열 포인터 seoulgu2 에 대입을 하네요. 이게 가능할까요? 불가능한 것입니다. 다음을 보세요. char (*sp)[3]; char *sp[3]; 위의 내용은 전에 배웠듯이 부분 배열의 요소의 개수가 3개인 이차원 배열 의 포인터이지요. 아래의 내용은 방금 배운 것처럼 포인터를 3개 담을 수 있 는 일차원 포인터 배열 입니다. 구분이 가시나요? 괄호 하나 빼놓고 전부 똑 같지만 의미는 판이하게 다릅니다. 그림으로 보도록 하지요. char (*sp)[3]; sp [0] [1] [2] ┏━━━━━━━┓ ┏━┳━┳━┓ ┃ ┃ ┃ ┃ ┣━━━━━━━━━━▶┃ ┃ ┃ ┃[0] ┗━━━━━━━┛ ┣━╋━╋━┫ ┃ ┃ ┃ ┃[1] ┣━╋━╋━┫ · · · · · · char *sp[3]; sp ┏━━━━━━━┓ sp[0] ┏━┳━┳━┳━┳━┳━┳ ┃ ┃ ┃ ┃ ┣━━━━━━━━━━▶┃ ┃ ┃ ┃ ┃ ┃ ┃… ┣━━━━━━━┫ ┗━┻━┻━┻━┻━┻━┻ ┃ ┃ ┃ ┃ ┣━━━━━┓ sp[1] ┏━┳━┳━┳━┳━┳━┳ ┣━━━━━━━┫ ┗━━━━▶┃ ┃ ┃ ┃ ┃ ┃ ┃… ┃ ┃ ┃ ┃ ┣━━━┓ ┗━┻━┻━┻━┻━┻━┻ ┗━━━━━━━┛ ┃ sp[2] ┏━┳━┳━┳━┳━┳━┳ ┗━━━━━━▶┃ ┃ ┃ ┃ ┃ ┃ ┃… ┗━┻━┻━┻━┻━┻━┻ 굳이 대입을 하고 싶다면 seoulgu2[0] = seoulgu1[0] 같이 일일히 해야하지 만, 그러면 의미가 많이 바뀌게 되겠지요. 제가 여기서 포인터 배열이 이차원 배열보다 무지무지 좋은 것처럼 말씀을 드리긴 했지만 항상 그런건 결코 아닙니다. seoulgu1에 문자열을 대입할 때 각각의 문자열을 strcpy로 대입하지 않고 선언시에 초기화 했다고 합시다. char seoulgu1[10][16] = { "Kangnam-gu", "Mapo-gu", "Chung-gu", "Kwanak-gu", "Nowon-gu", "Seoungbuk-gu", "Seocho-gu", "Dobong-gu", "Youngdeungpo-gu", "Songpa-gu" }; 이 경우에 사용되는 메모리는 정확히 160 바이트 입니다. 왜일까요? 선언과 동시에 초기화 되면 seoulgu1은 그대로 배열 상수로 사용되어 포인터 배열처 럼 메모리에 존재하는 문자열들을 직접 포인트하기 때문이지요. 또한 상수이 기 때문에 포인터 배열처럼 따로 메모리를 차지하지도 않지요. 그러면 이차원 배열이 더 좋은 걸수도 있겠네요. 그렇습니다. 이들은 사용하는 방법 등에 따라서 각기 더 좋을 수도 있고 더 나쁠 수도 있는 것이지요. 이차원 배열이 더 좋은 경우는 문자열들의 길이가 크게 차이가 나지 않는 경우 입니다. 반면에 문자열들의 길이가 크게 차이나 는 경우는 그 크기가 일괄적으로 잡히는 이차원 배열보다는 문자열들의 길이 를 모두 다르게 잡을 수 있는 포인터 배열이 더 유리한 것이지요. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ◐ 세번째 스터디가 끝났습니다. 다음 스터디를 기대해 주세요. 이해가 안 되 시는 내용이나 궁금한 사항이나 하여튼 아무 말이라도 하고 싶으시면 언제 라도 메일 주세요. (여태까지 볼랜드씨를 구한다는 메일 한통을 제외하고 는 단 한 통도 안 왔네요. 다들 잘 아시나봐요. 다 아시는데 괜히 하는 건 아닐지… ==;) ◐ 다음 문제들을 한번 풀어 보세요. ① 배열의 첨자가 0에서 시작하는 이유는? <힌트> 배열의 []연산자가 실제로는 어떻게 사용되는지 생각해 보세요. ② int a[6]; a[0] = 1[a] = *(a + 2) = *(3 + a) = 0; 4[a] = "ABC"[0]; a[5] = 1["DEF" + 1]; 위의 예에서 a의 각 요소 0부터 5까지의 값을 예상해 보세요. ③ char *sp = "School of Computing";에서 puts 함수로 "Computing"만 출 력해 보세요. ④ 증가 연산자를 사용해 문자열의 길이를 계산하는 함수를 만드세요. ⑤ int ia[2][3][4];에서 ia의 주소가 30이라고 할때 다음 각각의 주소와 타입, 크기를 예상해 보세요. => ia[1], ia[0][3], ia[1][2][0], ia[0], ia[0][1] ⑥ 다음과 같은 형태의 문자열 배열을 할당하는 방법을 생각해 보세요. [0] [1] [2] [3] [4] [5] [6] [7] [8] ┏━┳━┳━┳━┳━┳━┳━┳━┳━┓ [0]┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┣━╋━╋━╋━╋━┻━┻━┻━┻━┛ [1]┃ ┃ ┃ ┃ ┃ ┣━╋━╋━╋━╋━┳━┳━┓ [2]┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┣━╋━╋━╋━╋━╋━╋━┛ [3]┃ ┃ ┃ ┃ ┃ ┃ ┃ ┗━┻━┻━┻━┻━┻━┛ ◐ 정답(?)은 다음 시간에… ^^; ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━