콘텐츠 대표 이미지 - C언어 쌉고수 로드맵: 1차원 배열, 선언부터 활용까지 그냥 다 떠먹여드림

C언어 쌉고수 로드맵: 1차원 배열, 선언부터 활용까지 그냥 다 떠먹여드림

안녕, 코딩 뉴비 친구! 혹시 이런 생각해 본 적 없어?

게임을 만드는데, 몬스터 100마리의 체력을 저장해야 한다고 상상해봐.
아니면 우리 반 학생 30명의 시험 점수를 관리해야 하거나.
설마... 이렇게 할 거야?

으악! 상상만 해도 끔찍한 코드

int monster_hp_1;
int monster_hp_2;
int monster_hp_3;
// ... (이걸 100번까지...?)
int monster_hp_100;

int student_score_1;
int student_score_2;
// ... (아... 제발)
int student_score_30;
        

생각만 해도 손가락이 저려오지 않아? 😱
변수 이름을 짓는 것도 일이고, 이걸 하나하나 관리하는 건 거의 고문에 가까울 거야.
만약 몬스터가 1000마리로 늘어나면? 학생이 50명으로 늘어나면? 야근 확정이지.

바로 이럴 때, 우리를 구원해 줄 **마법 같은 도구**가 등장해. 그 이름은 바로 **'배열(Array)'**이야!
배열 하나만 제대로 배워두면, 저런 말도 안 되는 반복 작업을 단 몇 줄의 코드로 깔끔하게 처리할 수 있게 돼.
마치 인벤토리 확장 가방을 얻은 것처럼, 수많은 데이터를 아주 효율적으로 관리할 수 있는 거지.

오늘 이 글에서는 C언어의 핵심 중의 핵심, **1차원 배열**에 대해서 알아볼 거야.
'배열이 뭐지?' 하는 완전 쌩초보부터, '어렴풋이는 아는데 맨날 헷갈려' 하는 친구들까지 모두 환영해.
내가 아주 친한 친구한테 설명해주듯이, 하나부터 열까지 차근차근, 아주 그냥 씹어서 떠먹여 줄게. 이것만 다 읽으면 '아, 배열 완전 내 거 됐네!' 하는 생각이 들게 될 거야. 준비됐어? 그럼, 시작해보자!

오늘 우리가 정복할 내용들 🗺️

1. **배열의 정체 파악:** 그래서 배열이 대체 뭔데? (개념 잡기)
2. **배열 만들기:** 내 마음대로 배열을 선언하고 초기화하는 법.
3. **배열 사용하기:** 배열 속 데이터, 자유자재로 꺼내고 넣는 법. (feat. 인덱스)
4. **배열의 영혼의 파트너, 반복문:** 배열과 for문이 만나면 생기는 마법.
5. **절대 밟으면 안 되는 지뢰:** '배열 범위 초과'라는 무시무시한 버그.
6. **실전 프로젝트:** 배운 내용으로 간단한 성적 관리 프로그램 만들어보기.

1. 배열(Array)의 정체: 그래서, 그게 뭔데?

좋아, '배열'이라는 단어는 들어봤는데 정확히 뭐냐고? 아주 간단해.
**배열은 같은 종류의 데이터(자료형) 여러 개를 하나로 묶어서, 메모리상에 나란히 저장해 놓은 데이터 보관함**이야.

핵심 키워드는 두 가지!
**첫째, '같은 종류의 데이터'**
정수(int)들을 모아두면 '정수 배열', 실수(float)들을 모아두면 '실수 배열'이 되는 거야. 정수랑 실수를 마구 섞어서 하나의 배열에 담을 수는 없어. 딱 한 가지 종류만 통해!

**둘째, '메모리상에 나란히 저장'**
이게 진짜 중요한 개념이야. 컴퓨터 메모리라는 거대한 공간에, 우리가 만든 데이터들이 차곡차곡 순서대로 자리를 잡고 있다는 뜻이지.

비유를 들어볼까?

  • **아파트:** '래미안'이라는 아파트 단지(배열)에는 101호, 102호, 103호... (배열의 각 칸)가 있지. 모든 집은 '32평형'이라는 동일한 구조(같은 자료형)를 가지고 있고, 호수는 순서대로 쫙 이어져 있잖아. 이게 바로 배열이야.
  • **기차:** KTX 열차(배열)에는 1호차, 2호차, 3호차... (배열의 각 칸)가 연결되어 있지. 모든 칸은 '일반석'이라는 동일한 등급(같은 자료형)이고, 순서대로 붙어있어. 이것도 배열이지.
  • **달걀판:** 달걀 30개를 담는 판(배열)을 생각해봐. 모든 칸(배열의 각 칸)은 '달걀'이라는 똑같은 것(같은 자료형)만 담을 수 있고, 칸들이 규칙적으로 나열되어 있잖아. 완벽한 배열의 예시야.
배열의 메모리 구조 (int scores[5];) 데이터들이 메모리에 나란히 줄 서 있는 모습! 1000번지 1004번지 1008번지 1012번지 1016번지 scores[0] scores[1] scores[2] scores[3] scores[4] 95 88 100 72 90 * int가 4바이트라고 가정할 때, 각 요소의 메모리 주소는 4씩 차이 나게 됩니다.

위 그림처럼 `int scores[5];` 라고 선언하면, 정수(int) 5개를 담을 수 있는 공간이 메모리에 연속으로 쫙~ 할당되는 거야.
만약 첫 번째 공간의 주소가 1000번지이고, int가 4바이트 크기를 차지한다면, 그 다음 공간은 자동으로 1004번지, 그 다음은 1008번지가 되는 거지. 컴퓨터는 이 순서를 정확히 알고 있어.

그래서 우리는 뭘 할 수 있냐고?
변수 100개를 선언하는 대신, **"정수 100개짜리 배열 하나 만들어줘!"** 라고 컴퓨터에게 시킬 수 있게 된 거야.
이게 바로 배열의 존재 이유이자, 우리가 배열을 배워야 하는 가장 큰 이유지.

2. 배열 만들기: 선언과 초기화, 첫 단추 끼우기

자, 개념은 잡았으니 이제 직접 배열을 만들어 볼 시간이야. 배열을 만드는 과정은 크게 '선언'과 '초기화' 두 단계로 나눌 수 있어.

2-1. 배열 선언하기: "이런 공간 만들어줘!"

배열 선언은 컴퓨터에게 '나 이런이런 데이터를 몇 개 담을 수 있는 공간이 필요하니까, 자리 좀 맡아놔!' 라고 말하는 과정이야. 문법은 아주 간단해.

`자료형 배열이름[배열크기];`

하나씩 뜯어보자.

  • **자료형 (Data Type):** 이 배열에 어떤 종류의 데이터를 담을지 알려주는 거야. `int`, `float`, `double`, `char` 등 C언어의 모든 기본 자료형이 올 수 있어.
  • **배열이름 (Array Name):** 우리가 만들 배열에 붙여주는 이름이야. 변수 이름 짓는 규칙과 똑같아. `scores`, `ages`, `temperatures` 처럼 의미를 알 수 있게 짓는 게 센스!
  • **[배열크기] (Array Size):** 대괄호 `[]` 안에 이 배열이 총 몇 개의 데이터를 담을 수 있는지 숫자로 적어주는 거야. **배열의 칸 수**라고 생각하면 쉬워.

예시를 보면 바로 이해될 거야.

배열 선언 예시

// 정수(int) 10개를 저장할 수 있는 배열 'scores' 선언
int scores[10];

// 실수(float) 7개를 저장할 수 있는 배열 'temperatures' 선언
float temperatures[7];

// 문자(char) 20개를 저장할 수 있는 배열 'name' 선언
// (C언어에서 문자열은 보통 이런 식으로 문자 배열로 다루지!)
char name[20];
        

🚨 잠깐! 배열 선언할 때 이건 꼭 지켜줘!

배열의 크기를 지정할 때는 **'상수(Constant)'**를 사용해야 해. 즉, 변하지 않는 딱 정해진 숫자여야 한다는 뜻이야.
`int n = 10; int arr[n];` 이런 코드는 최신 C 컴파일러(C99 표준 이상)에서는 '가변 길이 배열(VLA)'이라는 기능으로 지원하기도 하지만, 전통적인 C 표준(C89/ANSI C)에서는 에러를 발생시켜. 호환성이나 예측 가능성을 위해, 초보 단계에서는 **배열 크기는 반드시 숫자로 직접 적거나, `const` 키워드를 사용한 상수로 지정**하는 습관을 들이는 게 좋아.


// 좋은 예시 👍
int arr1[10];
const int SIZE = 5;
int arr2[SIZE];

// 나쁜 예시 (초보 단계에서는 피하자) 👎
int size_variable = 10;
int arr3[size_variable]; // C89/90 표준에서는 컴파일 에러!
        

2-2. 배열 초기화하기: "만들면서 내용물도 채워줘!"

배열을 선언하면 일단 공간만 만들어진 상태야. 각 칸에는 어떤 값이 들어있을까?
정답은 **'알 수 없다'**야. 정확히는 이전에 그 메모리 공간을 사용했던 프로그램이 남겨둔 **'쓰레기 값(Garbage Value)'**이 들어있어.

이런 쓰레기 값을 그대로 사용하면 프로그램이 예측 불가능하게 동작하겠지? 그래서 우리는 배열을 만들 때, 깨끗하게 원하는 값으로 채워주는 '초기화' 과정을 거치는 게 좋아.

초기화하는 방법은 몇 가지가 있어.

방법 1: 선언과 동시에 모든 값 초기화하기

가장 기본적이고 확실한 방법이야. 중괄호 `{}` 안에 원하는 값들을 쉼표(`,`)로 구분해서 넣어주면 돼.

선언과 동시에 초기화

// 정수 배열 5칸을 만들고, 각각 10, 20, 30, 40, 50으로 채운다.
int numbers[5] = {10, 20, 30, 40, 50};

// 실수 배열 3칸을 만들고, 각각 1.1, 2.2, 3.3으로 채운다.
float points[3] = {1.1f, 2.2f, 3.3f}; // float형 상수는 뒤에 f를 붙여주는게 좋아!

// 문자 배열 5칸을 만들고, 'H', 'E', 'L', 'L', 'O'로 채운다.
char greeting[5] = {'H', 'E', 'L', 'L', 'O'};
        

방법 2: 선언과 동시에 일부만 초기화하기

만약 배열 크기보다 적은 개수의 값만 중괄호 안에 넣어주면 어떻게 될까?
C언어는 아주 친절하게도, **초기화되지 않은 나머지 칸들을 모두 0으로 채워줘!** 이건 정말 유용한 기능이야.

일부만 초기화하기

// 5칸짜리 배열인데, 값은 2개만 줬다.
int numbers[5] = {10, 20};

// 이 경우, numbers 배열의 상태는?
// numbers[0] = 10
// numbers[1] = 20
// numbers[2] = 0  <-- 자동으로 0으로 채워짐!
// numbers[3] = 0  <-- 자동으로 0으로 채워짐!
// numbers[4] = 0  <-- 자동으로 0으로 채워짐!
        

이 원리를 이용하면, 배열의 모든 요소를 0으로 아주 간단하게 초기화할 수 있어.

모든 요소를 0으로 초기화하는 꿀팁!

// 100칸짜리 배열의 모든 요소를 0으로 만들고 싶을 때
int data[100] = {0}; // 이렇게만 해주면 끝! 100칸 모두 0이 된다.
        

방법 3: 크기 생략하고 초기화하기

초기화할 값의 개수가 명확하다면, 굳이 배열 크기를 직접 적어주지 않아도 돼.
컴파일러가 중괄호 `{}` 안에 있는 값의 개수를 세어서, 알아서 배열 크기를 정해줘. 완전 스마트하지?

크기 생략 초기화

// 컴파일러가 알아서 {1, 2, 3} 3개의 값이 있으니, 크기가 3인 배열로 만들어준다.
int numbers[] = {1, 2, 3}; // int numbers[3] = {1, 2, 3}; 과 동일

// 'H', 'i', '!', '\0' 총 4개의 문자가 있으니, 크기가 4인 배열로 만들어준다.
char message[] = "Hi!"; // 문자열 리터럴로 초기화하는 특별한 경우.
// 사실 이건 char message[] = {'H', 'i', '!', '\0'}; 와 같아.
// 문자열의 끝을 알리는 널(Null) 문자 '\0'가 자동으로 포함돼!
        

자, 이제 우리는 배열이라는 데이터 보관함을 만들고, 원하는 물건(값)으로 채우는 방법까지 마스터했어. 그럼 다음 단계는? 당연히 이 보관함에서 물건을 꺼내고, 새로운 물건을 넣는 방법을 배워야겠지!

3. 배열 사용하기: 인덱스(Index)로 자유자재 컨트롤!

배열을 만들었으면 써먹어야지! 배열의 각 칸에 접근해서 값을 읽거나 새로운 값을 저장하려면, 우리는 **'인덱스(Index)'**라는 개념을 사용해야 해.

인덱스는 쉽게 말해 **배열의 각 칸에 붙어있는 '방 번호'** 라고 생각하면 돼.
아파트 101호, 102호처럼 각 칸을 구분해주는 고유 번호지.

그런데 여기서 C언어, 아니 대부분의 프로그래밍 언어에서 가장 중요하고, 초보자들이 가장 많이 실수하는 포인트가 등장해.

🚨🚨🚨 경고! 우주 대중요! 배열의 인덱스는 0부터 시작한다! 🚨🚨🚨

다시 한 번 말할게. **배열의 첫 번째 칸은 1번이 아니라 0번이야!**
만약 5칸짜리 배열 `arr[5]`가 있다면, 이 배열의 칸 번호(인덱스)는 1, 2, 3, 4, 5가 아니라 **0, 1, 2, 3, 4** 가 되는 거야.

- 첫 번째 요소: `arr[0]` - 두 번째 요소: `arr[1]` - ... - 다섯 번째 (마지막) 요소: `arr[4]`

이걸 헷갈리는 순간, 온갖 버그들이 너를 괴롭히기 시작할 거야. '왜 0부터 시작해요?' 라고 묻는다면, '메모리 주소를 기준으로 첫 번째 요소는 기준 주소로부터 0만큼 떨어진 곳에 있기 때문'이라고 기술적으로 설명할 수 있지만, 지금은 그냥 **'원래 그래! 이건 법이야!'** 라고 외우고 몸에 익히는 게 훨씬 중요해.

인덱스(Index)는 0부터 시작! int numbers[5] = {10, 20, 30, 40, 50}; 10 20 30 40 50 인덱스 0 인덱스 1 인덱스 2 인덱스 3 인덱스 4 (첫 번째 칸) (다섯 번째 칸) 절대 잊지 마! 첫 번째는 [0], 마지막은 [크기-1]

3-1. 배열 요소에 접근하기 (값 읽기)

배열의 특정 칸에 들어있는 값을 알고 싶을 때는 `배열이름[인덱스]` 형식을 그대로 사용하면 돼. 이건 그냥 변수 하나랑 똑같이 취급할 수 있어.

배열 요소 값 읽기 예제

#include <stdio.h>

int main(void) {
    int numbers[5] = {10, 20, 30, 40, 50};

    // 첫 번째 요소(인덱스 0)의 값을 출력
    printf("첫 번째 값: %d\n", numbers[0]); // 출력: 첫 번째 값: 10

    // 세 번째 요소(인덱스 2)의 값을 출력
    printf("세 번째 값: %d\n", numbers[2]); // 출력: 세 번째 값: 30

    // 마지막 요소(인덱스 4)의 값을 변수에 저장
    int last_value = numbers[4];
    printf("마지막 값: %d\n", last_value); // 출력: 마지막 값: 50

    // 배열 요소끼리 연산도 가능!
    int sum = numbers[0] + numbers[1];
    printf("첫 번째와 두 번째 값의 합: %d\n", sum); // 출력: 첫 번째와 두 번째 값의 합: 30

    return 0;
}
        

3-2. 배열 요소에 값 저장/수정하기

반대로 배열의 특정 칸에 새로운 값을 넣거나, 기존의 값을 바꾸고 싶을 때도 똑같아.
`배열이름[인덱스] = 새로운값;` 형식으로 사용하면 돼.

배열 요소 값 수정하기 예제

#include <stdio.h>

int main(void) {
    int scores[4] = {0}; // 모든 요소를 0으로 초기화

    printf("수정 전: %d, %d, %d, %d\n", scores[0], scores[1], scores[2], scores[3]);
    // 출력: 수정 전: 0, 0, 0, 0

    // 각 요소에 새로운 값을 저장
    scores[0] = 95; // 첫 번째 칸에 95를 저장
    scores[1] = 88; // 두 번째 칸에 88을 저장
    scores[2] = 100;
    scores[3] = 76;

    printf("수정 후: %d, %d, %d, %d\n", scores[0], scores[1], scores[2], scores[3]);
    // 출력: 수정 후: 95, 88, 100, 76

    // 기존의 값을 수정
    printf("수정 전 2번째 점수: %d\n", scores[1]); // 출력: 수정 전 2번째 점수: 88
    scores[1] = 92; // 88이 들어있던 두 번째 칸의 값을 92로 변경
    printf("수정 후 2번째 점수: %d\n", scores[1]); // 출력: 수정 후 2번째 점수: 92

    return 0;
}
        

어때? '인덱스는 0부터'라는 규칙만 머릿속에 딱 박아두면, 배열의 각 칸을 다루는 건 일반 변수를 다루는 것과 전혀 다를 게 없지? 아주 쉬워.

하지만 여기서 또 다른 질문이 생길 거야.
"아니, 그래서 배열을 쓰는 이유가 고작 이거야? `scores[0]`, `scores[1]`, `scores[2]`... 이렇게 하나하나 쓰는 건 `score1`, `score2`, `score3` 쓰는 거랑 뭐가 달라?"

정곡을 찔렀어. 만약 우리가 배열을 이렇게만 쓴다면, 그건 배열의 진짜 힘을 10%도 활용하지 못하는 거야.
배열의 진정한 가치는 바로 다음에 배울 **'반복문'**과 만났을 때 폭발적으로 발휘돼.

4. 배열의 영혼의 파트너, 반복문 (Loop)

드디어 배열의 '화룡점정'을 찍을 시간이야.
배열은 왜 인덱스를 0, 1, 2, 3... 처럼 규칙적인 숫자로 가지고 있을까?
바로 **반복문**을 이용해서 이 인덱스 숫자를 0부터 차례대로 증가시키며, 배열의 모든 칸에 순차적으로 접근하기 위함이야!

특히 `for`문은 배열과 거의 한 몸이라고 봐도 될 정도로 찰떡궁합을 자랑해.

배열과 찰떡궁합, for문의 기본 구조

int arr[5]; // 크기가 5인 배열 (인덱스는 0, 1, 2, 3, 4)

// for문을 이용해서 배열의 모든 칸에 접근하기
for (int i = 0; i < 5; i++) {
    // 여기서 i는 0, 1, 2, 3, 4 로 순서대로 변한다.
    // 즉, i가 바로 배열의 인덱스 역할을 하게 되는 것!
    // arr[i] 라고 쓰면, arr[0], arr[1], arr[2]... 에 차례로 접근할 수 있다.
}
        

`for (int i = 0; i < 배열크기; i++)` 이 구문은 그냥 외워둬. 배열을 다룰 때 거의 99% 이 형태로 사용하게 될 거야.
`i`가 0부터 시작해서, `배열크기 - 1` 까지 1씩 증가하니까, 배열의 모든 인덱스를 정확히 한 번씩 방문할 수 있지.

이제 이 마법 같은 조합으로 뭘 할 수 있는지 직접 보자.

4-1. 반복문으로 배열에 값 입력받기

학생 5명의 성적을 키보드로 입력받아 배열에 저장하는 코드를 짜볼까?
반복문이 없다면 `scanf`를 5번 써야 했겠지만, 이제는 아니야.

for문으로 5명의 성적 입력받기

#include <stdio.h>

int main(void) {
    int scores[5]; // 5명의 성적을 저장할 배열

    printf("5명의 성적을 입력하세요.\n");

    for (int i = 0; i < 5; i++) {
        // i가 0일 때: "1번째 학생 성적: " 출력 후 scores[0]에 값 입력
        // i가 1일 때: "2번째 학생 성적: " 출력 후 scores[1]에 값 입력
        // ...
        // i가 4일 때: "5번째 학생 성적: " 출력 후 scores[4]에 값 입력
        printf("%d번째 학생 성적: ", i + 1); // 사용자에게는 1번째부터 보여주는 센스!
        scanf("%d", &scores[i]);
    }

    printf("\n입력이 완료되었습니다.\n");
    // 이제 scores 배열에는 5명의 성적이 모두 저장되어 있다!

    return 0;
}
        

4-2. 반복문으로 배열의 모든 값 출력하기

입력받은 성적을 다시 화면에 예쁘게 출력해볼까? 이것도 반복문 하나면 끝!

for문으로 배열의 모든 요소 출력하기

#include <stdio.h>

int main(void) {
    int scores[5] = {95, 88, 100, 76, 92}; // 값이 이미 저장되어 있다고 가정

    printf("--- 학생 성적 목록 ---\n");
    for (int i = 0; i < 5; i++) {
        // i가 0~4로 변하면서 scores[0]부터 scores[4]까지 순서대로 출력
        printf("%d번째 학생의 성적: %d\n", i + 1, scores[i]);
    }
    printf("---------------------\n");

    return 0;
}
        

4-3. 반복문으로 배열 값 계산하기 (총점, 평균)

배열의 진정한 힘은 데이터 '처리'에서 나타나. 5명 성적의 총점과 평균을 구해보자.

for문으로 총점과 평균 계산하기

#include <stdio.h>

int main(void) {
    int scores[5] = {95, 88, 100, 76, 92};
    int sum = 0; // 총점을 저장할 변수, 반드시 0으로 초기화!
    float average = 0.0f; // 평균을 저장할 변수

    // 1. 총점 계산하기
    for (int i = 0; i < 5; i++) {
        // sum = sum + scores[i]; 와 같은 의미
        // 기존 sum 값에 배열의 요소를 계속 더해나간다.
        sum += scores[i];
    }

    // 2. 평균 계산하기
    // 총점(sum)을 학생 수(5)로 나눈다.
    // (float)를 붙여서 정수 나눗셈이 아닌 실수 나눗셈이 되도록 형변환!
    average = (float)sum / 5;

    printf("성적 총점: %d점\n", sum);
    printf("성적 평균: %.2f점\n", average); // 소수점 둘째 자리까지 출력

    return 0;
}
        

어때? `for`문과 배열의 조합, 정말 강력하지 않아?
만약 학생이 100명이라면? `int scores[100];` 으로 바꾸고, `for`문의 `i < 5` 를 `i < 100` 으로 바꾸기만 하면 돼. 코어 로직은 전혀 바꿀 필요가 없어. 이것이 바로 우리가 그토록 변수 100개를 선언하기 싫었던 이유에 대한 완벽한 해답이야.

혹시 코딩을 배우다가 막히는 부분이 생기거나, 나만의 프로젝트를 진행해보고 싶은데 방향을 잡기 어렵다면, 재능 공유 플랫폼 **재능넷** 같은 곳에서 C언어 전문가들의 도움을 받아보는 것도 좋은 방법이야. 숙련된 개발자의 1:1 코칭은 혼자 끙끙 앓는 것보다 훨씬 빠르게 실력을 키워줄 수 있거든.

5. 절대 밟으면 안 되는 지뢰: 배열 범위 초과 (Array Out of Bounds)

자, 이제 거의 다 왔어. 마지막으로 C언어 배열을 다룰 때 가장 조심해야 할, 가장 위험한 실수에 대해 알려줄게. 바로 **'배열의 할당된 범위를 벗어나서 접근하는 것'**이야.

예를 들어, 5칸짜리 배열 `int arr[5];` 를 선언했다고 해보자.
우리가 접근할 수 있는 유효한 인덱스는 몇 번부터 몇 번까지지? 맞아, **0, 1, 2, 3, 4** 까지야.

그런데 만약 우리가 실수로 `arr[5]` 나 `arr[10]`, 심지어 `arr[-1]` 같은, 존재하지 않는 인덱스에 접근하려고 하면 어떻게 될까?

💣 Undefined Behavior (정의되지 않은 행동) 💣

파이썬이나 자바 같은 다른 언어들은 이런 실수를 하면 "IndexError: list index out of range" 같은 친절한 에러 메시지를 보여주면서 프로그램을 즉시 중단시켜.

하지만 C언어는... **아무런 경고도 해주지 않아.**
C 컴파일러는 프로그래머를 '모든 것을 알고 있는 신'으로 가정하기 때문에, "네가 `arr[5]`에 접근하라고 시켰으니, 나는 그냥 할게. 그게 무슨 결과를 낳을지는 네 책임이야." 라는 스탠스를 취해.

이런 상황을 **'정의되지 않은 행동(Undefined Behavior)'**이라고 불러. 말 그대로, 어떤 일이 일어날지 아무도 예측할 수 없다는 뜻이야.

  • 운이 좋으면: 프로그램이 그 즉시 비정상적으로 종료된다. (Segmentation fault)
  • 운이 나쁘면: 프로그램이 당장은 멀쩡하게 돌아가는 것처럼 보인다. 하지만 실제로는 배열의 범위를 벗어나서, 다른 중요한 변수가 저장된 메모리 공간의 값을 엉망으로 덮어쓰거나, 운영체제가 사용하는 영역을 건드려서 나중에 프로그램 전체가 이상하게 동작하거나 다운되는 원인이 된다.
  • 운이 최악이면: 이게 보안 취약점으로 이어진다. (버퍼 오버플로우 공격)

아래 코드를 봐봐. 아주 흔하게 저지르는 실수야.

배열 범위 초과 오류의 흔한 예시

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5}; // 인덱스는 0, 1, 2, 3, 4

    // 이런 실수를 정말 많이 한다!
    // i < 5 라고 해야 하는데, i <= 5 라고 써버렸다.
    for (int i = 0; i <= 5; i++) {
        // i가 0, 1, 2, 3, 4 일 때는 정상 동작
        // 하지만 i가 5가 되는 순간! arr[5]에 접근하게 된다.
        // arr[5]는 존재하지 않는 공간!
        printf("arr[%d] = %d\n", i, arr[i]);
    }
    // 이 코드를 실행하면, 마지막 줄에 이상한 쓰레기 값이 출력되거나
    // 프로그램이 그냥 죽어버릴 수 있다.

    return 0;
}
        

이런 실수를 막으려면 어떻게 해야 할까?

  1. **`for`문 조건을 항상 확인한다:** `for (int i = 0; i < 배열크기; i++)` 형태를 철저히 지킨다. `<` 를 `<=` 로 잘못 쓰는 실수를 하지 않도록 항상 주의하자.
  2. **배열 크기를 명확히 인지한다:** 내가 만든 배열의 크기가 얼마인지, 그래서 유효한 인덱스 범위가 어디부터 어디까지인지 항상 머릿속에 새겨둬야 해.
  3. **`sizeof` 연산자 활용하기:** 배열의 크기가 코드 중간에 바뀔 수도 있는 복잡한 상황에서는, `sizeof`를 이용해 배열의 요소 개수를 알아내서 반복문에 활용하는 것이 더 안전해.
    int arr[] = {10, 20, 30, 40, 50, 60};
    int size = sizeof(arr) / sizeof(arr[0]); // 24바이트 / 4바이트 = 6
    for (int i = 0; i < size; i++) {
        // 이렇게 하면 배열 크기가 바뀌어도 for문을 수정할 필요가 없다!
    }

배열 범위 초과 버그는 찾기도 어렵고, 프로그램 전체를 불안정하게 만드는 주범이야. 코딩할 때 항상 경계심을 갖고, 내 코드가 할당된 메모리 안에서만 안전하게 놀고 있는지 확인하는 습관을 들이자!

6. 실전! 미니 프로젝트: 간단한 성적 관리 프로그램 만들기

자, 이론은 충분히 배웠어. 이제 배운 모든 것을 총동원해서 작은 프로그램을 하나 만들어보자.
이 프로젝트를 스스로의 힘으로 완성하고 나면, 배열에 대한 자신감이 한층 더 붙을 거야!

프로젝트 목표 🎯

5명 학생의 C언어 성적을 입력받아서, 다음 정보를 출력하는 프로그램을 만든다.
1. 입력된 전체 학생의 성적 목록
2. 성적 총점과 평균 점수
3. 최고 점수와 최저 점수

전체 코드를 먼저 보여주고, 각 부분을 단계별로 설명해 줄게.

전체 소스 코드: 성적 관리 프로그램

#include <stdio.h>

#define NUM_STUDENTS 5 // 학생 수를 상수로 정의하면 나중에 바꾸기 편하다!

int main(void) {
    // 1. 변수 및 배열 선언
    int scores[NUM_STUDENTS]; // 5명의 성적을 저장할 배열
    int sum = 0;              // 총점을 저장할 변수
    float average = 0.0f;     // 평균을 저장할 변수
    int max_score;            // 최고 점수를 저장할 변수
    int min_score;            // 최저 점수를 저장할 변수

    // 2. 성적 입력받기
    printf("=== %d명의 C언어 성적 입력 ===\n", NUM_STUDENTS);
    for (int i = 0; i < NUM_STUDENTS; i++) {
        printf("%d번 학생 성적: ", i + 1);
        scanf("%d", &scores[i]);
    }
    printf("============================\n\n");

    // 3. 총점 및 평균 계산
    for (int i = 0; i < NUM_STUDENTS; i++) {
        sum += scores[i];
    }
    average = (float)sum / NUM_STUDENTS;

    // 4. 최고 점수 및 최저 점수 찾기
    // 일단 첫 번째 학생의 점수를 최고/최저 점수라고 가정하고 시작한다.
    max_score = scores[0];
    min_score = scores[0];

    // 두 번째 학생(인덱스 1)부터 마지막 학생까지 점수를 비교한다.
    for (int i = 1; i < NUM_STUDENTS; i++) {
        // 현재 최고 점수(max_score)보다 더 큰 점수가 나타나면
        if (scores[i] > max_score) {
            max_score = scores[i]; // 최고 점수를 그 값으로 교체!
        }
        // 현재 최저 점수(min_score)보다 더 작은 점수가 나타나면
        if (scores[i] < min_score) {
            min_score = scores[i]; // 최저 점수를 그 값으로 교체!
        }
    }

    // 5. 결과 출력
    printf("--- 최종 성적 리포트 ---\n");
    printf("입력된 성적: ");
    for (int i = 0; i < NUM_STUDENTS; i++) {
        printf("%d점 ", scores[i]);
    }
    printf("\n\n");

    printf("총점: %d점\n", sum);
    printf("평균: %.2f점\n", average);
    printf("최고 점수: %d점\n", max_score);
    printf("최저 점수: %d점\n", min_score);
    printf("------------------------\n");

    return 0;
}
        

프로젝트 코드 해부하기

1단계: 변수 및 배열 선언

프로그램에 필요한 모든 저장 공간을 미리 만드는 단계야.
`int scores[NUM_STUDENTS];` : 학생들의 성적을 담을 핵심적인 배열이야. 학생 수를 `#define`을 이용해 상수로 만들어두면, 나중에 학생 수가 10명으로 바뀌어도 맨 윗줄 `NUM_STUDENTS` 값만 10으로 고치면 되니 아주 편리해.
`sum`, `average`, `max_score`, `min_score` : 계산 결과를 저장할 변수들이지.

2단계: 성적 입력받기

이미 위에서 배운 내용이지? `for`문을 이용해서 `NUM_STUDENTS` 만큼 반복하면서 `scanf`로 `scores` 배열의 각 칸(`scores[i]`)에 차곡차곡 성적을 저장하고 있어.

3단계: 총점 및 평균 계산

이것도 배운 내용 그대로야. `for`문을 돌면서 `sum` 변수에 `scores[i]` 값을 계속 누적해서 더해주고, 반복이 끝나면 `sum`을 학생 수로 나누어 평균을 구해.

4단계: 최고/최저 점수 찾기 (⭐중요 로직⭐)

이 부분이 조금 새롭고 재미있는 로직이야. 어떻게 여러 개의 값 중에서 가장 큰 값과 작은 값을 찾을 수 있을까?

  • 먼저, **기준점**을 정하는 거야. `max_score = scores[0];`, `min_score = scores[0];` 코드는 일단 배열의 첫 번째 값(`scores[0]`)이 가장 크고, 동시에 가장 작다고 '가정'하고 시작하는 거야.
  • 그 다음, `for`문을 **두 번째 값(`scores[1]`)부터** 돌면서 방금 정한 기준점과 비교를 시작해.
  • `if (scores[i] > max_score)`: 만약 현재 최고 점수라고 생각했던 `max_score`보다 더 큰 `scores[i]`가 나타나면? '아, 내가 잘못 알았네. 얘가 진짜 최고 점수구나!' 하고 `max_score`의 값을 새로운 값으로 업데이트하는 거지.
  • `if (scores[i] < min_score)`: 최저 점수도 마찬가지 원리야. 현재 최저 점수보다 더 작은 값이 나타나면, 그 값으로 `min_score`를 업데이트해.
  • 이 과정을 배열의 끝까지 반복하고 나면, `max_score` 변수에는 진짜 최고 점수가, `min_score` 변수에는 진짜 최저 점수가 남게 되는 거야.

이 '기준점 설정 후 비교하며 업데이트' 로직은 앞으로 프로그래밍하면서 정말 많이 사용하게 될 알고리즘 패턴이니까, 꼭 이해하고 넘어가자!

5단계: 결과 출력

지금까지 계산한 모든 결과를 `printf`를 이용해 사용자에게 보기 좋게 보여주는 마지막 단계야. 입력된 성적 목록을 보여줄 때도 `for`문을 사용해서 배열의 모든 요소를 깔끔하게 출력하고 있지.

직접 이 코드를 타이핑해서 실행해보고, 학생 수를 바꿔보거나, 다른 종류의 데이터를 다루는 프로그램으로 개조해보는 연습을 해봐. 예를 들어, 7일간의 온도를 입력받아 평균 온도와 가장 더웠던 날, 가장 추웠던 날의 온도를 구하는 프로그램으로 바꿔볼 수도 있겠지?

마치며: 배열, 너 내 동료가 돼라!

와, 정말 긴 여정이었어! 여기까지 포기하지 않고 따라온 너 자신에게 박수를 보내줘. 짝짝짝! 👏
오늘 우리는 C언어 프로그래밍의 레벨을 한 단계 올려줄 강력한 무기, **1차원 배열**에 대해 정말 깊숙이 파고들었어.

다시 한번 정리해볼까?

  • 배열은 **같은 자료형**의 데이터를 **연속된 메모리**에 저장하는 효율적인 도구다.
  • `자료형 이름[크기];`로 선언하고, `{}`를 이용해 초기화할 수 있다.
  • 배열의 각 칸은 **0부터 시작하는 인덱스**로 접근한다. (`array[0]`, `array[1]`, ...)
  • 배열은 **`for` 반복문**과 함께 사용할 때 진정한 힘을 발휘한다.
  • **배열 범위를 벗어나는 접근**은 C언어에서 가장 위험한 실수 중 하나이니 항상 조심해야 한다.

이제 너는 더 이상 변수 100개를 선언하는 무식한(?) 방법으로 코딩하지 않아도 돼. 수많은 데이터를 배열 하나로 우아하게 관리하고, 반복문으로 순식간에 처리하는 '진짜 프로그래머'의 길에 한 걸음 더 다가선 거야.

물론 배열의 세계는 여기서 끝이 아니야. 오늘 배운 1차원 배열을 확장한 **2차원 배열**(엑셀 시트 같은 격자무늬 데이터), 그리고 배열과 떼려야 뗄 수 없는 관계인 **포인터(Pointer)**라는 더 흥미진진한 모험이 너를 기다리고 있어. 하지만 조급해하지 마. 오늘 배운 1차원 배열을 자유자재로 다룰 수 있게 되는 것이 가장 중요해.

스스로에게 작은 프로젝트를 내주면서 계속 연습해봐. 오늘 만든 성적 관리 프로그램을 더 발전시켜도 좋고, 간단한 숫자 야구 게임이나 로또 번호 생성기 같은 걸 만들어보는 것도 훌륭한 연습이 될 거야. 만약 더 체계적인 학습이나 전문가의 피드백이 필요하다면, **재능넷**과 같은 플랫폼에서 너의 코딩 여정을 도와줄 멘토를 찾아보는 것도 좋은 선택지가 될 수 있어.

오늘 정말 고생 많았고, 너의 코딩 실력이 한 뼘 더 성장했음을 진심으로 축하해! 🔥

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.