[흥달쌤] 깨알 C언어) 배열, 포인터, scanf와 변수, 배열과 포인터

[깨알 C언어 21~28 영상]

 

 

※ 배열이란?

   • 같은 자료형의 변수를 연속적으로 묶어 놓은 저장공간

int a[5];

a[0] = 10;
a[2] = 20;
a[6] = 60;

// 실행 과정 + 결과

int a[5];

// 배열 크기 5
// 사용할 수 있는 인덱스: 0 ~ 4

// 메모리 구조
// a[0] a[1] a[2] a[3] a[4]

a[0] = 10;
// 정상
// a[0]에 10 저장

a[2] = 20;
// 정상
// a[2]에 20 저장

a[6] = 60;
// 오류
// 배열 범위 초과
// a[6]은 존재하지 않음
// (배열 인덱스 범위: 0~4)

// 결과 상태

// a[0] = 10
// a[1] = ? (초기화 안됨)
// a[2] = 20
// a[3] = ? (초기화 안됨)
// a[4] = ? (초기화 안됨)

// a[6] 접근 → 범위 초과(Out of Bounds)

 

※ 이차원 배열

   • 같은 자료형의 변수를 행과 열의 연속적인 공간으로 묶어 놓은 것

int a[2][3];

a[0][0]  a[0][1]  a[0][2]
a[1][0]  a[1][1]  a[1][2]

int a[2][3];

// 행(Row) 2개, 열(Column) 3개
// 인덱스 범위 → 행: 0~1, 열: 0~2

a[0][0] = 10;
a[0][1] = 20;
a[0][2] = 30;

a[1][0] = 40;
a[1][1] = 50;
a[1][2] = 60;


// 메모리 형태

      열
      0    1    2
행
0    10   20   30
1    40   50   60

 

---

 

[문] 다음 C 프로그램의 출력 결과는?

void main(){
    char msg[50] = "Hello World! Good Luck!";
    int i = 2, number = 0;

    while(msg[i] != '!'){
        if(msg[i] == 'a' || msg[i] == 'e' || msg[i] == 'i' ||
           msg[i] == 'o' || msg[i] == 'u')
            number++;

        i++;
    }

    printf("%d", number);
    return 0;
}

 

→ ① 2

 

// 실행 과정 + 결과

char msg[50] = "Hello World! God Luck!";
int i = 2, number = 0;

// 문자열 인덱스

// 0:H
// 1:e
// 2:l  ← 시작 위치
// 3:l
// 4:o
// 5:' '
// 6:W
// 7:o
// 8:r
// 9:l
// 10:d
// 11:! ← 종료 조건

while(msg[i] != '!'){
    // 모음(a,e,i,o,u) 개수 세기

    // i=2 → l
    // i=3 → l
    // i=4 → o → number=1
    // i=5 → 공백
    // i=6 → W
    // i=7 → o → number=2
    // i=8 → r
    // i=9 → l
    // i=10 → d

    i++;
}

// i=11에서 msg[i]=='!'
// 반복 종료

printf("%d", number);

// 최종 출력 결과
// 2

 

---

 

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

void main(){
    int i;
    char ch;
    char str[7] = "nation";

    for(i = 0; i < 4; i++){
        ch = str[5-i];
        str[5-i] = str[i];
        str[i] = ch;
    }

    printf("%s\n", str);
    return 0;
}

 

 

① nanoit   ② nation   ③ noitan   ④ notian

 

→ ④ notian

 

// 실행 과정 + 결과

char str[7] = "nation";

// 초기 상태
// n a t i o n
// 0 1 2 3 4 5

for(i = 0; i < 4; i++){

// i = 0
// str[5] ↔ str[0]
// n ↔ n
// 결과: nation

// i = 1
// str[4] ↔ str[1]
// o ↔ a
// 결과: notian

// i = 2
// str[3] ↔ str[2]
// i ↔ t
// 결과: noitan

// i = 3
// str[2] ↔ str[3]
// t ↔ i
// 다시 원상복구
// 결과: notian
}

/* 포인트!! */

// 문자열 길이 = 6
// 정상적으로 뒤집으려면

for(i = 0; i < 3; i++)

// 또는

for(i = 0; i < strlen(str)/2; i++)

// 그런데 문제는 i < 4 이므로
// 가운데 문자를 한 번 더 교환하여
// 완전한 역순(noitan)이 아니라 notian이 됨

 

---

 

※ 포인터란?

   • 메모리의 위치를 표현한 기호

 

※ 포인터 변수 선언

int *a;
// a : 포인터 변수
// int형 데이터의 주소를 저장

*a = 10;
// a가 가리키는 주소에 10 저장

printf("%d", a);
// a가 저장한 주소 출력
// 결과: 100

printf("%d", *a);
/ 주소 100번지에 있는 값 출력
// 결과: 10


/* 포인트!! */

int num = 10;
int *a = #

printf("%p\n", a);   // 주소 출력 (100)
printf("%d\n", *a);  // 값 출력 (10)

a   = 주소
*a  = 주소가 가리키는 실제 값

 

※ 변수의 주소 찾기

int b = 10;

int *a;

a = &b;

printf("%d\n", *a);

printf("%d\n", b);

// 실행 과정 + 결과

int b = 10;

// b의 값 = 10

int *a;

// 포인터 변수 선언

a = &b;

// &b : b의 주소
// a는 b의 주소를 저장

// 예시
// b의 주소가 100번지라고 가정

// a = 100


/* 메모리 구조 */

변수 b

주소      값
100       10

포인터 a

주소      값
200       100


/* 출력 과정 */

printf("%d\n", *a);

// a가 저장한 주소 = 100
// *a = 주소 100번지의 값
// 결과: 10

printf("%d\n", b);

// b의 값 출력
// 결과: 10

// 최종 출력 결과
10
10


/* 포인트!! */

a   = 주소값
&a  = a 자신의 주소
*b  = 사용 불가 (b는 포인터가 아님)
*a  = a가 가리키는 곳의 값

int b = 10;
int *a = &b;

a    // b의 주소
&a   // a의 주소
b    // 10
*a   // 10

 

---

 

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

#include <stdio.h>

void main(){
    int A = 10, B;
    int *C = &B;

    B = A--;
    B += 20;

    printf("%d", *C);
}

 

① 28   ② 29   ③ 30   ④ 31

 

→ ③ 30

 

// 실행 과정 + 결과

int A = 10, B;
int *C = &B;

// C는 B의 주소를 저장
// *C는 B의 값과 동일

B = A--;
// 후위 감소 연산자

// 1) A의 현재값 10을 B에 대입
//    B = 10

// 2) 이후 A 감소
//    A = 9

B += 20;

// B = B + 20
// B = 10 + 20
// B = 30

printf("%d", *C);

// C는 B를 가리킴
// *C = B = 30

// 출력 결과
// 30

 

---

 

※ scanf

   • 사용자의 키보드로 입력받을 때 사용하는 함수

// 형식

scanf("%d", 변수의주소);

 

※ scanf 사용법

int a;

scanf("%d", &a);

printf("%d", a);

// 실행 과정 + 결과

int a;

// 변수 a 선언

scanf("%d", &a);

// 사용자가 정수 입력

// 예시 입력
10

// a에 10 저장

printf("%d", a);

// a의 값 출력
// 결과: 10


/* 포인트!! */

scanf("%d", &a);   // O
scanf("%d", a);    // X

scanf는 값을 저장할 위치(주소)가 필요하므로 변수 앞에 '&'를 붙인다

 

---

 

[문] 다음 C 프로그램을 실행한 결과로 옳은 것은?
      (단, 아래의 scanf() 함수의 입력으로 90을 타이핑했다고 가정)

int main(){
    int i = 10;
    int j = 20;
    int *k = &i;

    scanf("%d", k);

    printf("%d, %d, %d\n", i, j, *k);
    return 0;
}

 

① 10, 20, 10
② 10, 20, 90
③ 90, 20, 10
④ 90, 20, 90

 

→ ④ 90, 20, 90

 

// 실행 과정 + 결과

int i = 10;
int j = 20;
int *k = &i;

// k는 i의 주소를 저장
// *k와 i는 같은 메모리를 가리킴

scanf("%d", k);

// k == &i 이므로

// scanf("%d", &i);

// 와 동일한 의미

// 사용자가 90 입력

// i = 90

printf("%d, %d, %d\n", i, j, *k);


/* 포인트!! */

int *k = &i;

scanf("%d", k);

k 자체가 이미 i의 주소(&i)를 저장하고 있으므로
scanf("%d", k);는 scanf("%d", &i);와 동일하다

 

---

 

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

#include <stdio.h>
int main(void){
    int i;
    int a[] = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
    int *ptr = a + 3;

    for(i = 0; i < 5; ++i){
        printf("%d", *(ptr+i)-3);
    }
}

 

① 27 37 47 57 67
② 37 47 57 67 77
③ 47 57 67 77 87
④ 43 53 63 73 83

 

→ ② 37 47 57 67 77

 

// 실행 과정 + 결과

int a[] = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
// 인덱스:
// a[0]=10, a[1]=20, a[2]=30, a[3]=40, a[4]=50
// a[5]=60, a[6]=70, a[7]=80, a[8]=90, a[9]=100

int *ptr = a + 3;
// ptr은 a[3]의 주소를 가리킴
// *ptr = 40

for(i = 0; i < 5; ++i){
    printf("%d", *(ptr+i)-3);
}

// i=0 → *(ptr+0) = a[3] = 40 → 40-3 = 37
// i=1 → *(ptr+1) = a[4] = 50 → 50-3 = 47
// i=2 → *(ptr+2) = a[5] = 60 → 60-3 = 57
// i=3 → *(ptr+3) = a[6] = 70 → 70-3 = 67
// i=4 → *(ptr+4) = a[7] = 80 → 80-3 = 77

// 최종 출력
// 37 47 57 67 77

 

---

 

※ 배열과 포인터의 관계

int a[5];

int *b = a;

a[2] = 10;

b[2] = 20;

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

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

배열명은 배열의 시작 주소를 의미한다
따라서 int *b = a; 이면 b[2]와 a[2]는 같은 메모리 공간을 가리킨다

 

---

 

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

#include <stdio.h>

int main(void){
    int a[] = { 1, 2, 4, 8 };
    int *p = a;

    p[1] = 3;
    a[1] = 4;
    p[2] = 5;

    printf("%d %d\n", a[1] + p[1], a[2] + p[2]);

    return 0;
}

 

→ 8 10

 

// 실행 과정 + 결과

int a[] = { 1, 2, 4, 8 };

인덱스
0  1  2  3
1  2  4  8

int *p = a;

// p는 a[0]을 가리킴
// p[1] == a[1]
// p[2] == a[2]

p[1] = 3;

// a[1] = 3

배열 상태
{1, 3, 4, 8}

a[1] = 4;

// a[1] = 4

배열 상태
{1, 4, 4, 8}

p[2] = 5;

// a[2] = 5

배열 상태
{1, 4, 5, 8}

a[1] + p[1]

// a[1] = 4
// p[1] = a[1] = 4

// 결과 = 8

a[2] + p[2]

// a[2] = 5
// p[2] = a[2] = 5

// 결과 = 10


/* 최종 출력 */

printf("%d %d\n", a[1] + p[1], a[2] + p[2]);

// 출력 결과
8 10


/* 포인트!! */

int *p = a;

// p[i] == a[i]

p[1] = 3;
// a[1]도 3으로 변경

p[2] = 5;
// a[2]도 5로 변경

배열과 포인터가 같은 메모리를 가리키므로
한쪽에서 값을 변경하면 다른 쪽에서도 동일하게 보인다
8 10

 

---

 

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

#include <stdio.h>

int main(void){
    int a[4] = { 10, 20, 30 };
    int *p = a;

    p++;

    *p++ = 100;
    *++p = 200;

    printf("a[0]=%d, a[1]=%d, a[2]=%d\n",
           a[0], a[1], a[2]);
}

 

→ a[0]=10, a[1]=100, a[2]=30

 

// 실행 과정 + 결과

int a[4] = { 10, 20, 30 };

// 초기 상태

// a[0] = 10
// a[1] = 20
// a[2] = 30
// a[3] = 0

int *p = a;   // p → a[0]

p++;          // p → a[1]

*p++ = 100;   // 연산자 우선순위 *(p++) = 100;

// 현재 p는 a[1]을 가리킴

// a[1] = 100 저장
// 그 다음 p 증가

// 배열
// {10, 100, 30, 0}

// p → a[2]

*++p = 200;   // *(++p) = 200;

// 먼저 p 증가

// p → a[3]

// a[3] = 200 저장

// 배열
// {10, 100, 30, 200}


/* 최종 배열 상태 */

인덱스   값
a[0]    10
a[1]    100
a[2]    30
a[3]    200


/* 출력 계산 */

printf("a[0]=%d, a[1]=%d, a[2]=%d\n",
       a[0], a[1], a[2]);

// a[0] = 10
// a[1] = 100
// a[2] = 30


/* 최종 출력 */

a[0]=10, a[1]=100, a[2]=30

 

---

 

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

#include <stdio.h>

void main(){
    int num[4] = {1, 2, 3, 4};
    int *pt = num;

    pt++;
    *pt++ = 5;
    *pt++ = 10;
    pt--;
    *pt++ += 20;

    printf("%d %d %d %d",
           num[0], num[1], num[2], num[3]);
}

 

→ 1 5 30 4

 

// 실행 과정 + 결과

int num[4] = {1, 2, 3, 4};

// 초기 상태
// {1, 2, 3, 4}

int *pt = num;

// pt → num[0]

① pt++
pt++;
// pt → num[1]

② *pt++ = 5
*(pt++) = 5;
// num[1] = 5
// pt → num[2]

// 배열
// {1, 5, 3, 4}

③ *pt++ = 10
*(pt++) = 10;
// num[2] = 10
// pt → num[3]

// 배열
// {1, 5, 10, 4}

④ pt--
pt--;
// pt → num[2]

⑤ *pt++ += 20    // 연산자 우선순위상
(*(pt++)) += 20;
// 현재 pt는 num[2]를 가리킴

// num[2] += 20
// num[2] = 10 + 20 = 30

// 이후 pt → num[3]

// 배열
// {1, 5, 30, 4}


/* 최종 출력 */
printf("%d %d %d %d",
       num[0], num[1], num[2], num[3]);

// 출력 결과
// 1 5 30 4


/* 포인트!! */
*pt++ += 20
는
(*(pt++)) += 20
과 같다