👉🏻 C_dynamic memory management_CheatSheet_v1

🆚 Python vs C: 비교

---

🔍 예시 비교

✅ Python 예제

def hello():
    arr = [0] * 100  # 자동으로 메모리 할당됨
    print("Hello from Python!")

hello()
# 함수 종료 시, arr은 참조 카운트가 0이 되면 GC가 자동 해제

✅ C 예제

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

void hello() {
    int *arr = malloc(sizeof(int) * 4); // 처음부터 크기를 명시
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;
    arr[3] = 40;
    printf("%d %d %d %d\n", arr[0], arr[1], arr[2], arr[3]);
    free(arr); // 반드시 수동 해제
}

int main() {
    hello();
    return 0;
}

---

1. 메모리 관리 방식

Python 은 자동 메모리 관리 언어로, 사용자가 직접 메모리를 할당하거나 해제할 필요가 없다.
객체가 더 이상 참조되지 않으면 내부적으로 Garbage Collector(GC) 가 이를 감지하여 메모리를 해제한다.
이 GC는 주로 참조 카운팅(reference counting) 과 순환 참조 감지 알고리즘을 통해 작동한다.

C 에서는 메모리를 개발자가 직접 할당(malloc)하고 해제(free)해야 한다. 이 과정이 제대로 이루어지지 않는다면 메모리 누수(memory leak), 이중 해제(double free), 해제 후 접근(use after free) 같은 치명적인 버그가 발생할 수 있다.

---

출처 : https://gabrieletolomei.wordpress.com/miscellanea/operating-systems/in-memory-layout/

2. 변수의 저장 위치

Python 에서 모든 데이터는 객체로 다뤄지며, 이 객체들은 무조건 힙(Heap) 에 저장된다.
함수 내부 변수처럼 보이는 것도 실제로는 힙에 저장된 객체에 대한 참조(reference) 를 다루는 것이다.

C 에서는 함수 내에서 선언한 일반 변수는 스택(stack) 에 저장되고, 동적 할당된 데이터는 힙(heap) 에 저장된다.
C는 이처럼 스택과 힙을 명확히 구분해서 사용하는 반면, Python은 대부분의 데이터를 힙에 올린다고 보면 된다.

---

3. 동적 할당 및 해제

Python 에서는 리스트, 딕셔너리, 객체 등 모든 것이 "자동으로" 동적 할당되며 사용자가 직접 메모리를 해제하지 않아도 되는 대신 메모리 회수가 언제 일어날지 명확하게 예측하기는 어렵다.

C 에서는 명시적으로 malloc() 등으로 메모리를 할당하고, 반드시 free()로 반납해야 한다. 이를 소홀히 하면 메모리 누수가 발생하며, 긴 시간 실행되는 프로그램이나 서버에서는 치명적이다.

🔥 헷갈리면 안되는 것 !
두 언어 모두 힙 영역에 메모리를 잡는 동적할당을 사용하고 있으나

• C언어 → 크기 지정 필수, 개발자가 직접 관리 (malloc, free)
• Python → 크기 지정 불필요, 인터프리터가 자동 관리 (GC 포함)

---

4. 포인터 사용 여부

Python 에서는 포인터라는 개념이 사용자 코드에 드러나지 않는다.
모든 변수는 객체를 참조하는 "포인터 같은 것"이지만, 개발자는 이를 직접 조작할 수 없다.

C 언어는 포인터 기반 언어다. 배열, 함수 전달, 메모리 조작 등 다양한 상황에서
직접 주소를 다루는 포인터를 필수적으로 사용한다. 이로 인해 강력하지만, 실수에 매우 취약하다.

---

5. 성능과 안정성

Python 은 개발 생산성과 안정성을 중시하여 메모리 관리를 자동화했지만,
그만큼 런타임에서 추가적인 오버헤드가 발생한다.

C 에서는 메모리 관리를 수동으로 해야 하지만, 그만큼 정밀한 최적화가 가능하여 성능 중심의 개발에 유리하다.

---

6. 컴파일 방식과 실행

Python 은 C처럼 직접 기계어로 번역하는 것이 아니라 인터프리터가
중간 언어인 바이트코드를 한줄 한줄 해석하며 실행하기 때문에 속도가 느리다.

C 는 컴파일러 전체 소스코드를 기계어로 한번에 컴파일해서 실행파일을 생성하기 때문에 속도가 빠르다.

---

📌 동적 메모리 할당 (Dynamic Memory Allocation)

💬 동적 메모리 할당이란?

프로그램 실행 중에 필요한 만큼 메모리를 힙(Heap) 영역에 할당하는 것으로 사용자가 원하는 만큼의 메모리를 할당받고 중간에 더 필요하다면 추가로 할당을 필요하지 않다면 해제하는 방식을 말한다.

---

🆚 대비되는 개념

☑️ 정적 메모리 할당 (Static Memory Allocation)

• 컴파일 시점에 메모리 크기가 결정되며, 프로그램 종료까지 유지된다.
• 전역 변수, static 키워드 변수 등이 해당.
• 장점: 빠른 접근, 예측 가능한 메모리 사용
• 단점: 유연성이 없음 (크기 변경 불가)

#include <stdio.h>

// 전역 변수 (프로그램 전체에서 사용 가능)
int global_array[5]; 

int main() {
    static int static_array[5]; // 함수 내 static 변수
    for (int i = 0; i < 5; i++) {
        global_array[i] = i + 1;
        static_array[i] = (i + 1) * 10;
    }

    for (int i = 0; i < 5; i++) {
        printf("global[%d] = %d, static[%d] = %d\n", i, global_array[i], i, static_array[i]);
    }
    return 0;
}

---

☑️ 자동 메모리 할당 (Automatic Memory Allocation)

• 함수 호출 시 스택(Stack) 영역에 메모리 할당.
• 함수 종료 시 자동으로 해제됨.
• 지역 변수들이 해당.
• 장점: 메모리 해제를 신경 쓸 필요 없음
• 단점: 함수 종료 후 데이터 소멸

#include <stdio.h>

void func() {
    int local_array[5]; // 스택에 저장
    for (int i = 0; i < 5; i++) {
        local_array[i] = i + 1;
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", local_array[i]);
    }
    printf("\n");
}

int main() {
    func();
    // 여기서는 local_array에 접근 불가 (이미 해제됨)
    return 0;
}

변수 종류	예시	저장 위치	생성 시점	소멸 시점	특징
자동 변수 (Automatic)	int x = 0; (함수 내부)	스택(Stack)	함수 호출 시	함수 종료	기본 지역 변수, 메모리 자동 해제
정적 변수 (Static)	static int y = 0; (함수 내부)	데이터 영역(Data Segment)	프로그램 시작	프로그램 종료	함수 호출이 끝나도 값 유지
전역 변수 (Global)	int g = 0; (함수 외부)	데이터 영역(Data Segment)	프로그램 시작	프로그램 종료	모든 함수에서 접근 가능
동적 변수 (Dynamic)	malloc(sizeof(int) * 10);	힙(Heap)	malloc 호출 시	free 호출 시	크기 실행 중 결정, 수동 해제 필요

---

🛠️ 주요 함수

⚙️ malloc

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

int main() {
    int *arr = malloc(sizeof(int) * 5); // int 5개 공간 할당
    if (arr == NULL) {
        printf("메모리 할당 실패\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    free(arr); // 해제
    return 0;
}

💡 Point

1. 초기화 안 함
   • 할당한 메모리의 값은 쓰레기 값(이전 메모리 잔재)이다.
   • 필요한 경우 memset 등으로 직접 초기화해야 한다.

 int arr[5];
    memset(arr, 0, sizeof(arr)); // 모든 바이트를 0으로 채움 

2. 속도가 빠름
   • 초기화를 안 하므로 calloc보다 일반적으로 빠르다.
3. 크기 지정 필수
   • sizeof(타입) * 개수 형태로 바이트 크기를 직접 계산해야 한다.
4. 사용 시 주의점
   • NULL 반환 가능성 체크 필요.
   • 초기화 안 하면 쓰레기 값 때문에 디버깅이 어려워질 수 있다.

---

⚙️ calloc

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

int main() {
    int *arr = calloc(5, sizeof(int)); // int 5개 공간 할당 + 0으로 초기화
    if (arr == NULL) {
        printf("메모리 할당 실패\n");
        return 1;
    }

    printf("calloc으로 할당된 배열 (0으로 초기화됨):\n");
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]); // 전부 0 출력
    }
    printf("\n");

    free(arr);
    return 0;
}

💡 Point

1. 0으로 초기화
   • 할당된 메모리 전체를 0으로 채운다(정수는 0, 포인터는 NULL).
2. 인자 두 개
   • calloc(개수, 크기) 형태로 사용. 내부적으로 두 값을 곱해 전체 크기를 계산한다.
3. 안전성
   • 초기화 덕분에 예측 불가능한 쓰레기 값 문제를 피할 수 있어 디버깅이 편하다.
4. 속도는 다소 느림
   • 0 초기화 과정 때문에 malloc보다 약간 느릴 수 있다(대부분 미미한 차이).

---

⚙️ realloc

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

int main() {
    int *arr = malloc(sizeof(int) * 3); // 처음 3칸 할당
    if (arr == NULL) {
        printf("메모리 할당 실패\n");
        return 1;
    }

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

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

    // 크기를 5칸으로 확장
    arr = realloc(arr, sizeof(int) * 5);
    if (arr == NULL) {
        printf("메모리 재할당 실패\n");
        return 1;
    }

    printf("realloc 후 (늘어난 부분 초기화 안 됨, 쓰레기 값 가능):\n");
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    free(arr);
    return 0;
}

💡 Point

1. 크기 변경
   • 기존 메모리 블록의 크기를 늘리거나 줄인다.
2. 데이터 유지
   • 기존 데이터는 그대로 보존하되, 확장된 부분은 초기화 안 한다(쓰레기 값 가능).
3. 메모리 위치 변경 가능성
   • 내부적으로 새 메모리 블록을 할당하고 기존 내용을 복사할 수 있어, 원래 포인터 값이 바뀔 수 있다.
4. 동적 확장에 유리
   • 점진적으로 데이터 크기가 커지는 경우(예: 동적 배열 구현)에 효율적이다.
5. 주의점
   • realloc 실패 시 NULL을 반환하고, 기존 포인터는 그대로 유지됨.
     그래서 기존 포인터를 바로 덮어쓰지 말고 임시 변수(tmp)에 받아서 확인 후 교체하는 습관이 안전하다.

int *arr = malloc(sizeof(int) * 5);

// 크기 늘리기
arr = realloc(arr, sizeof(int) * 10); // ⚠️ 위험
if (arr == NULL) {
    // 여기 오면 arr에 NULL이 들어감 → 기존 메모리 주소 잃어버림 → 메모리 누수 발생
}

---

☑️ malloc, calloc, realloc, free

주요 함수명	기능	특징
malloc(size)	size 바이트 만큼 메모리 할당	초기화 안 되어 있음 (쓰레기 값)
calloc(n, size)	n개 × size 바이트 할당	0으로 초기화
realloc(ptr, size)	기존 메모리 크기 변경	데이터 유지하면서 크기 조절
free(ptr)	할당한 메모리 해제	필수 호출, 안 하면 메모리 누수 발생

---

⚠️ 주의사항

1. free 반드시 호출
   • 동적 할당 메모리를 해제하지 않으면 메모리 누수(memory leak) 발생.
2. 할당 실패 체크
   • 메모리 부족 시 NULL 반환 → 반드시 확인.
3. 해제 후 포인터 초기화

   free(arr);
   arr = NULL;

   프로그램이 바로 종료되는 경우는 필요하지 않지만 이후 동작이 남아있다면 잘못된 사용을 막기 위해 해당 과정 필수
   즉, free(arr)는 할당 받은 메모리를 회수했을 뿐 해당 포인터는 아직 그 주소를 가리키고 있다
4. 해제하지 않은 포인터 사용 금지
   • 해제 후 접근 시 use-after-free 오류 발생.

---

🛠️ 메모리 관련 주요 함수 정리

1️⃣ memset

void *memset(void *ptr, int value, size_t num);

• 기능: ptr이 가리키는 메모리 블록의 모든 바이트를 value로 채움.
• 사용 예: 배열 초기화, 구조체 초기화
• 특징:
  1. value는 바이트 단위로 해석됨 (예: memset(arr, 1, 4) → 각 바이트를 0x01로 채움)
  2. 구조체나 배열을 0으로 초기화할 때 가장 많이 사용
  3. 정수 0 이외의 값 채울 때 주의 (4바이트 int 전부 같은 바이트값으로 채워짐)

---

2️⃣ memcpy

void *memcpy(void *dest, const void *src, size_t num);

• 기능: src의 메모리 내용을 dest로 그대로 복사.
• 사용 예: 배열/구조체 복사, 버퍼 데이터 복사
• 특징:
  1. 겹치지 않는 메모리 영역에서만 안전 (overlap 발생 시 동작 예측 불가)
  2. 속도가 빠름 (겹침 고려 안 함)
  3. sizeof로 정확한 크기를 계산해서 사용해야 함

---

3️⃣ memmove

void *memmove(void *dest, const void *src, size_t num);

• 기능: src의 메모리 내용을 dest로 복사 (겹치는 영역도 안전하게 처리).
• 사용 예: 문자열 슬라이싱, 배열 내 일부 이동
• 특징:
  1. 내부적으로 임시 버퍼를 사용해 겹치는 경우에도 안전하게 복사
  2. memcpy보다 약간 느릴 수 있음 (안전성 대가)
  3. 겹치는 가능성이 있으면 무조건 memmove 사용 권장

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

int main() {
    // 1. malloc + memset (초기화)
    int *arr = malloc(sizeof(int) * 5);
    memset(arr, 0, sizeof(int) * 5); // 0으로 채우기

    // 2. 값 채우기
    for (int i = 0; i < 5; i++) arr[i] = i + 1;

    // 3. realloc (크기 확장)
    arr = realloc(arr, sizeof(int) * 8);
    memset(arr + 5, 0, sizeof(int) * 3); // 새로 늘어난 부분 0 초기화

    // 4. memcpy (복사)
    int *copy = malloc(sizeof(int) * 8);
    memcpy(copy, arr, sizeof(int) * 8);

    // 5. memmove (겹치는 영역 안전 복사)
    memmove(copy + 2, copy, sizeof(int) * 6);

    // 6. 출력
    for (int i = 0; i < 8; i++) printf("%d ", copy[i]);
    printf("\n");

    free(arr);
    free(copy);
    return 0;
}

📌 한눈에 비교

함수	용도	겹침 가능?	속도	주요 특징
memset	메모리 블록 채우기	N/A	빠름	바이트 단위 값 채움
memcpy	메모리 블록 복사	❌	매우 빠름	겹침 시 위험
memmove	메모리 블록 복사	✅	memcpy보다 느림	안전한 복사

---

👥 캐스팅 관련 토의

int *arr = malloc(sizeof(int) * 5);
int *arr = (int*)malloc(sizeof(int) * 5);

⭕️ 명시적 형변환 찬성

주요한 이유 :

1. C++ 와의 호환성

• C++은 void* → 다른 포인터 타입 자동 변환 불가
  → C++ 코드에서 malloc 쓰려면 캐스팅 필수.

2. 가독성

• 한눈에 "이 포인터는 int 배열"이라는 걸 명확히 보여줌.

3. 일관성

• malloc뿐 아니라 다른 포인터 변환에도 항상 명시적으로 캐스팅하는 습관을 유지.

⭕️ 명시적 형변환 반대

주요한 이유 :

1. C 표준에서는 불필요하다

• C89, C99, C11 모두 void* → 다른 포인터 타입 자동 변환 지원.

2. 버그 탐지 방해

• #include <stdlib.h>를 빼먹어도 캐스팅이 있으면 컴파일러 경고가 안 뜸.
  -> 결국 헤더를 안 넣어서 발생할 수 있는 심각한 버그(잘못된 반환 타입, 크기 불일치)를 초기에 못 잡게 될 수 있다.

3. 코드 단순화

• 불필요한 코드를 줄여서 가독성을 높일 수 있다.

Explicit is better than implicit
Trust the machine over the human