스택과 힙: 메모리 영역 이해

┌──────────────────┐
│   스택 (Stack)    │  ← 지역 변수, 함수 호출
├──────────────────┤
│       ↓          │
│                  │
│       ↑          │
├──────────────────┤
│    힙 (Heap)      │  ← malloc 동적 할당
├──────────────────┤
│   BSS Segment    │  ← 초기화 안 된 전역
├──────────────────┤
│   Data Segment   │  ← 초기화된 전역/static
├──────────────────┤
│   Code (Text)    │  ← 컴파일된 함수 코드
└──────────────────┘  낮은 주소

#include <stdio.h>
#include <stdlib.h>

int global_init = 100;       // Data
int global_uninit;            // BSS

void func(void) {
    int local = 1;            // Stack
    static int s = 5;         // Data (한 번만 초기화)
    int *heap = malloc(16);   // Heap
    free(heap);
}

int main(void) {
    func();
    return 0;
}

#include <stdio.h>

void inner(void) {
    int x = 10;
    printf("inner: x = %p\n", (void*)&x);
}

void outer(void) {
    int y = 20;
    printf("outer: y = %p\n", (void*)&y);
    inner();
}

int main(void) {
    int z = 30;
    printf("main: z = %p\n", (void*)&z);
    outer();
    return 0;
}

// 출력 (스택은 보통 높은 주소→낮은 주소로 자람):
// main:  z = 0x7ffd1238
// outer: y = 0x7ffd1218   ← 더 낮은 주소
// inner: x = 0x7ffd11f8   ← 더 낮은 주소

[main 호출]
스택:
┌─────────────┐
│  return addr │ ← main 호출자의 다음 명령
│  saved %rbp  │ ← 이전 프레임 포인터
│  z = 30      │
└─────────────┘

[outer 호출]
스택:
┌─────────────┐
│  ...main 데이터... │
├─────────────┤
│  return addr │ ← main 함수 안의 다음 명령
│  saved %rbp  │
│  y = 20      │
└─────────────┘

[함수 종료]
- return addr 사용해 호출자로 복귀
- 스택 포인터 복구
- 지역 변수 사라짐

#include <stdio.h>

void recursive(int depth) {
    char buffer[1024];  // 1KB씩 스택 사용
    printf("depth = %d\n", depth);
    recursive(depth + 1);  // ⚠️ 종료 조건 없음
}

int main(void) {
    recursive(0);
    // 출력: depth=0, 1, 2, ... 수천 번 후 SIGSEGV
    // 스택 한도 (보통 8MB) 초과 → 세그폴트
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    // 런타임에 크기 결정
    int n;
    printf("배열 크기 입력: ");
    if (scanf("%d", &n) != 1 || n <= 0) {
        return 1;
    }

    // 힙에 할당
    int *arr = malloc(n * sizeof(int));
    if (arr == NULL) {
        fprintf(stderr, "메모리 부족\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = i * 10;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    free(arr);  // ⚠️ 반드시 free
    arr = NULL; // 다시 사용 방지

    return 0;
}

| 측면 | 스택 | 힙 |
|---|---|---|
| 할당 | 자동 (함수 호출 시) | 수동 (malloc) |
| 해제 | 자동 (함수 종료) | 수동 (free) |
| 속도 | 매우 빠름 | 느림 |
| 크기 | 작음 (보통 1~8MB) | 큼 (수 GB) |
| 수명 | 함수 범위 | 명시적 free까지 |
| 수정 | 컴파일 시 결정 | 런타임 가능 |
| 단편화 | 없음 | 있음 |

#include <stdio.h>
#include <stdlib.h>

int gi = 1;        // Data
int gu;            // BSS
const int gc = 5;  // Read-only

int main(void) {
    int local = 10;        // Stack
    static int s = 20;     // Data
    int *h = malloc(16);   // Heap

    printf("Code (main):    %p\n", (void*)main);
    printf("Read-only (gc): %p\n", (void*)&gc);
    printf("Data (gi):      %p\n", (void*)&gi);
    printf("BSS (gu):       %p\n", (void*)&gu);
    printf("Static (s):     %p\n", (void*)&s);
    printf("Heap (h):       %p\n", (void*)h);
    printf("Stack (local):  %p\n", (void*)&local);

    free(h);
    return 0;
}