[흥달쌤] 깨알 C언어) 2차원 배열과 포인터, 포인터 배열

[깨알 C언어 29~34 영상]

 

 

※ 2차원 배열

// 배열
 행	     값
a[0]	{1, 2}
a[1]	{3, 4}
a[2]	{5, 6}

// 주소
 행	   주소
a[0]	100
a[1]	102
a[2]	104



/* 포인트!! */

a      == &a[0]
*a     == a[0]
**a    == a[0][0]

a      -> 주소
*a     -> 주소
**a    -> 실제 값

즉,
a      : 2차원 배열의 시작 주소
*a     : 1차원 배열(a[0])
**a    : 실제 데이터(a[0][0])

 

---

 

[문] 다음 C 프로그램의 실행 결과로 옳은 것을 고르시오.

#include <stdio.h>

int main(){
    int data[][3] = {
        1, 3, 4,
        5, 2, 9,
        6, 8, 7
    };

    int *p = data[1];
    int x, y;

    x = *p;
    y = *(p+2);

    printf("x=%d, y=%d\n", x, y);
}

 

① x=1, y=3   ② x=1, y=4   ③ x=5, y=7   ④ x=5, y=9

 

→ ④ x=5, y=9

 

        [0] [1] [2]
data[0]  1   3   4
data[1]  5   2   9
data[2]  6   8   7


p = data[1] 이므로
p = &data[1][0]
즉 p는 5를 가리킴

x = *p;      // 5
y = *(p+2);  // 9


// 결과
x = 5
y = 9

 

---

 

[문] 다음 C 프로그램의 출력 값은?

#include <stdio.h>
int main(){
    int darr[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}};
    int sum1, sum2;

    sum1 = *(*darr+1) + *(*darr+2);
    sum2 = *darr[1] + *darr[2];

    printf("%d, %d", sum1, sum2);
}

 

→ 5, 11

 

// 실행 과정 + 결과

| 배열      | [0] | [1] | [2] |
| --------- | --- | --- | --- |
|  darr[0]  |   1 |   2 |   3 |
|  darr[1]  |   4 |   5 |   6 |
|  darr[2]  |   7 |   8 |   9 |


| 표현       | 의미                | 값 |
| ---------- | ------------------ | -- |
| *darr      | darr[0]의 시작 주소 |    |
| *(*darr+1) | darr[0][1]         | 2  |
| *(*darr+2) | darr[0][2]         | 3  |
| *darr[1]   | darr[1][0]         | 4  |
| *darr[2]   | darr[2][0]         | 7  |


sum1 = *(*darr+1) + *(*darr+2);  // 2 + 3 = 5
sum2 = *darr[1] + *darr[2];      // 4 + 7 = 11

printf("%d, %d", sum1, sum2);    // 5, 11


// 결과
5, 11

 

---

 

※ 포인터 배열

   • 배열의 요소가 포인터(메모리 주소)로 이루어진 것

// 일반 배열 vs 포인터 배열
| 선언       | 저장 내용    |
| ---------- | ----------- |
| int a[3];  | 정수        |
| int *p[3]; | 주소(포인터) |

// 예시 1
char a[3] = {'a', 'b', 'c'};
printf("%s\n", a);

| 인덱스  | 값  |
| ------ | --- |
|  a[0]  | 'a' |
|  a[1]  | 'b' |
|  a[2]  | 'c' |

%s 는 문자열 출력 → abc

// 예시 2
char *str = "Hello";
printf("%s\n", str);

str은 문자열 "Hello"의 시작 주소를 저장하는 포인터
| H | e | l | l | o | \0 |

| 선언                   | 의미                    |
| ---------------------- | ---------------------- |
| `char a[] = "Hello";`  | 문자열 배열             |
| `char *str = "Hello";` | 문자열을 가리키는 포인터 |

// 예시 3. 포인터 배열

char *student[3] = {"aaa", "bbb", "ccc"};


// 메모리 구조

student 배열
| 인덱스     | 저장값 |
| ---------- | ----- |
| student[0] | 20    |
| student[1] | 30    |
| student[2] | 40    |

즉 student는 문자열 주소를 저장하는 포인터 배열

실제 문자열
| 주소 | 문자열 |
| ---- | ----- |
| 20   | "aaa" |
| 30   | "bbb" |
| 40   | "ccc" |


student[0] → "aaa"
student[0] → "bbb"
student[0] → "ccc"


/* 포인트!! */
| 표현        | 결과   |
| ----------- | ----- |
| student[0]  | "aaa" |
| student[1]  | "bbb" |
| student[2]  | "ccc" |
| *student[0] | 'a'   |
| *student[1] | 'b'   |
| *student[2] | 'c'   |

 

---

 

[문] 다음 C 프로그램의 실행 결과는?

#include <stdio.h>

int main(){
    static char *c[] = {"aaa", "bbb", "ccc"};

    printf("%s", *(c+1));
}

 

→ bbb

 

// 배열 c

| 인덱스  | 값    |
| ------ | ----- |
|  c[0]  | "aaa" |
|  c[1]  | "bbb" |
|  c[2]  | "ccc" |


// 포인터 계산

| 표현   | 의미   | 결과             |
| ------ | ----- | ---------------- |
| c      | &c[0] | 첫 요소 주소      |
| c+1    | &c[1] | 두 번째 요소 주소 |
| *(c+1) | c[1]  | "bbb"            |


// 결과

printf("%s", *(c+1)); → printf("%s", "bbb");
→ bbb

 

---

 

[문] 다음 C 프로그램을 실행한 결과는?

#include <stdio.h>

int main(){
    char *array1[2] = {
        "Good morning",
        "C language"
    };

    printf("%s\n", array1[0]+5);
    printf("%c\n", *(array1[1]+6));
}

 

→ morning

    u

 

array1 구조

| 인덱스     | 문자열         |
| --------- | -------------- |
| array1[0] | "Good morning" |
| array1[1] | "C language"   |


① array1[0] + 5
Good morning
012345678901

| 위치 | 문자  |
| ---- | ---- |
| 0    | G    |
| 1    | o    |
| 2    | o    |
| 3    | d    |
| 4    | 공백 |
| 5    | m    |

array1[0] + 5 → "morning"


② *(array1[1] + 6)
C language
0123456789

| 위치 | 문자  |
| ---- | ---- |
| 0    | C    |
| 1    | 공백 |
| 2    | l    |
| 3    | a    |
| 4    | n    |
| 5    | g    |
| 6    | u    |

*(array1[1] + 6) → 'u'


// 결과

morning
u

 

---

 

[문] 다음 C 프로그램의 실행 결과는?

void main(){
    int a[2][3] = {{-3, 14, 5}, {1, -10, 8}};
    int *b[] = {a[0], a[1]};
    int *p = b[1];

    printf("%d", *b[1]);
    printf("%d", *(++p));
    printf("%d", *(--p-2));
}

 

→ 1-1014

 

// 배열 구조

| 배열 | [0] | [1] | [2] |
| ---- | --- | --- | --- |
| a[0] |  -3 |  14 |   5 |
| a[1] |   1 | -10 |   8 |


// 포인터 상태

| 표현     | 의미               |       값 |
| -------- | ----------------- | -------- |
| b[0]     | a[0] 시작 주소     | &a[0][0] |
| b[1]     | a[1] 시작 주소     | &a[1][0] |
| p = b[1] | p는 a[1][0] 가리킴 |        1 |


// 출력 계산

| 표현     | 의미               |       값 |
| -------- | ----------------- | -------- |
| b[0]     | a[0] 시작 주소     | &a[0][0] |
| b[1]     | a[1] 시작 주소     | &a[1][0] |
| p = b[1] | p는 a[1][0] 가리킴 |        1 |


// 결과

1-1014

 

---

 

[문] 다음 C언어에 대한 알맞는 출력값을 쓰시오.

#include <stdio.h>

int main(){
    int *arr[3];
    int a = 12, b = 24, c = 36;

    arr[0] = &a;
    arr[1] = &b;
    arr[2] = &c;

    printf("%d\n", *arr[1] + **arr + 1);
}

 

→ 37

 

// 포인터 배열

| 표현   | 가리키는 변수  |  값 |
| ------ | ------------- | -- |
| arr[0] | a             | 12 |
| arr[1] | b             | 24 |
| arr[2] | c             | 36 |


// 계산

| 표현    | 의미                 | 값 |
| ------- | ------------------- | -- |
| *arr[1] | b                   | 24 |
| *arr[0] | a                   | 12 |
| **arr   | **(arr+0) = *arr[0] | 12 |

*arr[1] + **arr + 1
= 24 + 12 + 1
= 37


// 결과

37


/* 포인트!! */

*arr[1] → b의 값
*arr[0] → a의 값
**arr → **(arr+0) = *arr[0] = a의 값