C 가 지금도 쓰이는 네 자리

C 와 C++ 는 얼마나 다른가

C 코드는 대부분 C++ 컴파일러로도 컴파일됩니다. 하지만 "C++ 는 C 의 상위 집합"이라는 말은 정확하지 않습니다 — void* 암묵 변환, 구조체 초기화, bool, new 같은 이름 등에서 실제로 어긋납니다.

더 중요한 차이는 문법이 아니라 사고방식입니다. C 에는 소멸자도, RAII 도, 템플릿도 없습니다. 모든 자원 관리를 사람이 직접 합니다. 그래서 규율이 필요하고, 그 규율이 무너진 자리에서 세상의 보안 취약점 절반이 나왔습니다.

리눅스 · WSL

sudo apt install build-essential gdb
gcc --version

# 컴파일 (경고를 최대로)
gcc -std=c17 -Wall -Wextra -g hello.c -o hello
./hello

macOS

xcode-select --install
clang --version

clang -std=c17 -Wall -Wextra -g hello.c -o hello
./hello

윈도우

# 방법 A — MSYS2 (gcc 를 그대로)
pacman -S mingw-w64-ucrt-x86_64-gcc

# 방법 B — Visual Studio (MSVC)
cl /std:c17 /W4 hello.c

첫 프로그램 — 한 줄씩 뜯어보기

#include <stdio.h>      // printf 의 '선언'만 가져옵니다 (구현은 링크 단계)

int main(void) {        // (void) = 인자를 받지 않는다는 명시
    printf("안녕, C\n");
    return 0;           // 0 = 정상 종료. 셸이 이 값을 읽습니다
}

int main() 와 int main(void) 는 C 에서 의미가 다릅니다. 앞의 것은 "인자 정보를 모른다"이고, 뒤의 것이 "인자가 없다"입니다. C++ 에서는 둘이 같아서 헷갈리기 쉽습니다.

경고 플래그를 반드시 켜세요

# 처음부터 이 조합으로 시작하세요
gcc -std=c17 -Wall -Wextra -Wpedantic \
    -Wshadow -Wconversion -g -O1 main.c -o app

# 개발 중에는 새니타이저까지
gcc -std=c17 -Wall -Wextra -g \
    -fsanitize=address,undefined main.c -o app

표준이 보장하는 것은 최소 크기뿐

그래서 실무에서는 stdint.h

#include <stdint.h>
#include <inttypes.h>   // 출력 형식 매크로

int32_t  a = -5;         // 정확히 32비트, 부호 있음
uint64_t b = 1ULL << 40; // 정확히 64비트, 부호 없음
size_t   n = 100;        // 길이 · 인덱스는 항상 size_t

// 출력할 때도 타입에 맞는 형식을 써야 합니다
printf("%" PRId32 " %" PRIu64 " %zu\n", a, b, n);

// ❌ printf("%d", n);   // size_t 를 %d 로 → UB

파일 형식 · 네트워크 프로토콜 · 다른 언어와 주고받는 구조체에는 반드시 고정 크기 타입을 쓰세요.

char 의 부호는 정해져 있지 않다

x86 에서는 부호 있음, ARM 에서는 부호 없음인 경우가 많습니다. 바이트를 다룰 때는 unsigned char 나 uint8_t 를 명시하세요.

정수 승격이 먼저 일어난다

uint8_t a=200, b=100; a+b 는 uint8_t 가 아니라 int 로 계산돼 300 이 됩니다. 다시 담을 때 잘리므로 중간 타입을 항상 의식해야 합니다.

나눗셈과 시프트

음수를 오른쪽으로 시프트하는 것은 구현 정의이고, 시프트 폭이 타입 비트 수 이상이면 UB 입니다. x >> 32 (32비트 int) 는 쓰면 안 됩니다.

배열이 포인터로 변하지 않는 자리

int a[10];

sizeof(a);      // 40  — 여기서는 배열 그대로
&a;             // int(*)[10] — 배열 전체의 주소 (타입이 다릅니다!)
_Alignof(a);    // 정렬도 배열 기준 (식에 쓰는 건 GCC 확장 — 표준은 _Alignof(int[10]))

// 나머지는 전부 첫 원소의 주소로 변합니다
int* p = a;     // == &a[0]
f(a);           // f 는 int* 를 받습니다

// &a 와 a 는 값은 같지만 타입이 다릅니다
a + 1;          // 4바이트 앞
&a + 1;         // 40바이트 앞 (!)

포인터 산술의 단위는 '타입 크기'

int  a[5] = {10,20,30,40,50};
int* p = a;

*(p + 2);       // 30 — 2 는 '2바이트'가 아니라 '원소 2개'(= 8바이트)
p[2];           // 정확히 같은 뜻 (a[i] == *(a+i))
2[a];           // 놀랍게도 이것도 합법입니다 (쓰지 마세요)

// 두 포인터의 차이는 '원소 개수'
ptrdiff_t d = &a[4] - &a[1];    // 3

// ⚠ 배열 범위를 넘은 포인터 연산 자체가 UB 입니다
int* q = a + 5;   // 끝 바로 뒤까지는 합법 (역참조는 불가)
int* r = a + 6;   // ❌ UB

연속된 진짜 2차원

int m[3][4];            // 12개가 한 덩어리로 연속

m[1][2];                // == *(*(m+1)+2)
sizeof(m);              // 48
sizeof(m[0]);           // 16 (한 행)

// 함수로 넘길 때 열 수는 반드시 알려야 합니다
void f(int m[][4], int rows);
void g(int (*m)[4], int rows);   // 같은 뜻

포인터 배열 (흩어진 행)

int** m = malloc(3 * sizeof(int*));
for (int i = 0; i < 3; i++)
    m[i] = malloc(4 * sizeof(int));   // 행마다 따로 할당

m[1][2];                // 두 번 역참조 — 캐시 미스가 늘어납니다

// 해제도 역순으로 전부
for (int i = 0; i < 3; i++) free(m[i]);
free(m);

쓰면 안 되는 함수와 대안

실무에서 쓰는 패턴

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

char buf[64];

// ① 만들기 — snprintf 하나면 충분합니다
int n = snprintf(buf, sizeof buf, "%s-%d", name, id);
if (n < 0 || (size_t)n >= sizeof buf) {
    /* 잘렸습니다. n 은 '필요했던 길이'를 알려 줍니다 */
}

// ② 읽기 — fgets 는 개행까지 함께 담습니다
if (fgets(buf, sizeof buf, stdin)) {
    buf[strcspn(buf, "\n")] = '\0';   // 개행 제거 관용구
}

// ③ 비교 — == 는 주소 비교입니다!
if (strcmp(a, b) == 0) { /* 같다 */ }

한글은 한 글자가 아닙니다

UTF-8 에서 한글 한 글자는 3바이트입니다. strlen("한글") 은 6 을 돌려줍니다. 바이트 수와 글자 수를 구분하세요 — 자르다가 깨지는 사고의 원인입니다.

POSIX · BSD 확장

strdup(복사본 할당) 은 POSIX, strlcpy/strlcat(항상 널 종료) 은 BSD·macOS 계열입니다. 이식성이 필요하면 snprintf 로 통일하세요.

길이를 들고 다니는 습관

큰 프로젝트는 대부분 { char* p; size_t len; } 같은 자체 문자열 구조체를 만들어 씁니다. 길이를 잃지 않는 것만으로 버그가 크게 줄어듭니다.

기본 네 함수

#include <stdlib.h>

int* p = malloc(n * sizeof *p);   // 쓰레기 값으로 채워져 있음
if (!p) { /* 실패 처리 — 반드시 검사 */ }

int* q = calloc(n, sizeof *q);    // 0 으로 초기화 + 곱셈 넘침 검사

int* r = realloc(p, m * sizeof *p);
if (!r) { free(p); return -1; }   // ⚠ 실패해도 p 는 살아 있습니다
p = r;                            //   바로 대입하면 p 를 잃습니다

free(p);
p = NULL;                         // 해제 후 NULL — 습관으로 만드세요

다섯 가지 함정

함수 이름과 주석으로 규약을 밝힌다

/* 반환값의 소유권은 호출자에게 넘어갑니다.
   다 쓴 뒤 buffer_free() 로 해제하세요. */
Buffer* buffer_create(size_t cap);
void    buffer_free(Buffer* b);

/* 반환값은 내부 버퍼를 가리킵니다.
   해제하지 마세요. b 가 살아 있는 동안만 유효합니다. */
const char* buffer_data(const Buffer* b);

C 에는 소유권을 표현할 문법이 없습니다. 이름 규칙(create/free 짝)과 const 가 유일한 도구입니다.

에러 처리 — goto 가 정답인 드문 자리

int load(const char* path, Result* out) {
    FILE*  f   = NULL;
    char*  buf = NULL;
    int    rc  = -1;

    f = fopen(path, "rb");
    if (!f)   goto done;

    buf = malloc(SIZE);
    if (!buf) goto done;

    if (fread(buf, 1, SIZE, f) != SIZE) goto done;

    out->data = buf;  buf = NULL;   // 소유권을 넘겼으니 여기서 비웁니다
    rc = 0;

done:
    free(buf);                     // NULL 이면 아무 일도 안 합니다
    if (f) fclose(f);
    return rc;
}

malloc 반환값 캐스팅

C 에서는 (int*)malloc(...) 처럼 캐스팅하지 않는 것이 권장됩니다. 캐스팅이 stdlib.h 를 빠뜨린 실수를 가려 버리기 때문입니다. (C++ 에서는 반대로 캐스팅이 필수입니다.)

스택에 잡는 것이 더 낫다

크기가 작고 함수 안에서만 쓴다면 지역 배열이 훨씬 빠르고 안전합니다. 스택은 보통 1~8MB 이므로, 수 KB 까지는 고민하지 말고 스택에 두세요.

아레나 · 풀 할당

수명이 같은 객체가 많다면 큰 덩어리를 한 번 잡고 잘라 쓰다가 한 번에 버리는 방식이 빠르고 누수도 없습니다. 게임·컴파일러에서 널리 쓰는 기법입니다.

확인하는 법

#include <stddef.h>
#include <stdio.h>

struct A { char a; int n; char b; };

printf("%zu\n", sizeof(struct A));          // 12
printf("%zu\n", offsetof(struct A, n));     // 4  ← 빈칸 3 뒤
printf("%zu\n", _Alignof(struct A));        // 4

// 컴파일 때 못 박아 두는 방법 (C11)
_Static_assert(sizeof(struct A) == 12, "레이아웃이 바뀌었습니다");

_Static_assert 를 걸어 두면, 누군가 필드를 추가해 레이아웃을 바꿨을 때 빌드가 막아 줍니다. 파일 형식·프로토콜 구조체에는 꼭 넣으세요.

빈칸을 없애는 packed — 그리고 대가

// GCC · Clang
struct __attribute__((packed)) Header {
    uint8_t  type;
    uint32_t length;      // 1바이트 위치에서 시작 — 정렬이 깨집니다
};

// MSVC
#pragma pack(push, 1)
struct Header { uint8_t type; uint32_t length; };
#pragma pack(pop)

union — 같은 자리를 여러 타입으로

// 크기는 '가장 큰 멤버' 하나 — 동시에 하나만 유효합니다
typedef struct {
    enum { INT, STR, DBL } tag;    // 무엇이 들었는지 표시
    union { int i; char* s; double d; } v;
} Value;

Value x = { .tag = INT, .v.i = 42 };

switch (x.tag) {
    case INT: printf("%d\n", x.v.i); break;
    /* ... */
}

비트필드 — 플래그를 촘촘히

struct Flags {
    unsigned enabled  : 1;
    unsigned mode     : 3;   // 0~7
    unsigned reserved : 4;
};   // 쓰는 비트는 8개 — 단 sizeof 는 보통 4 (unsigned 단위로 잡힘)

읽기 쉽지만 비트 배치 순서가 구현 정의입니다. 하드웨어 레지스터나 통신 프로토콜에는 직접 시프트와 마스크를 쓰는 편이 이식성이 높습니다.

문법 — 읽는 순서만 익히면 됩니다

int add(int a, int b) { return a + b; }

// 이름부터 안쪽으로 읽습니다: f 는 → 포인터 → 함수 → int 반환
int (*f)(int, int) = add;      // &add 라고 써도 같습니다
int r = f(2, 3);               // (*f)(2,3) 과 동일

// typedef 로 감싸면 훨씬 읽힙니다
typedef int (*BinOp)(int, int);
BinOp ops[] = { add, sub, mul };
int r2 = ops[0](2, 3);

// 괄호를 빼면 뜻이 완전히 달라집니다
int* g(int, int);              // int* 를 반환하는 함수 (포인터 아님)

qsort — 표준 라이브러리의 예

#include <stdlib.h>

int cmp_int(const void* a, const void* b) {
    int x = *(const int*)a, y = *(const int*)b;
    return (x > y) - (x < y);      // 뺄셈은 오버플로 위험이 있습니다
}

int a[5] = {3,1,4,1,5};
qsort(a, 5, sizeof a[0], cmp_int);

인터페이스 흉내 — 전체 모습

typedef struct Stream Stream;

typedef struct {
    ssize_t (*read )(Stream*, void*, size_t);
    ssize_t (*write)(Stream*, const void*, size_t);
    void    (*close)(Stream*);
} StreamOps;

struct Stream {
    const StreamOps* ops;   // 첫 필드에 두는 것이 관례
    /* 구현마다 다른 상태가 뒤에 옵니다 */
};

// 부르는 쪽은 구현을 전혀 모릅니다
ssize_t n = s->ops->read(s, buf, sizeof buf);

쓸 때 주의할 것

• NULL 검사 — 표의 함수가 비어 있을 수 있습니다
• 시그니처 불일치 — 잘못된 타입으로 부르면 UB. typedef 로 고정하세요
• 수명 — 콜백에 넘긴 void* 가 콜백이 불릴 때까지 살아 있어야 합니다
• C ABI 경계 — 다른 언어에서 넘어온 콜백은 호출 규약이 맞아야 합니다
• 등록 해제 — 콜백을 등록했으면 해제하는 함수도 함께 제공하세요

텍스트 읽기 — 한 줄씩

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

FILE* f = fopen("data.txt", "r");
if (!f) {
    fprintf(stderr, "열기 실패: %s\n", strerror(errno));
    return -1;
}

char line[256];
while (fgets(line, sizeof line, f)) {
    line[strcspn(line, "\n")] = '\0';
    /* 처리 */
}
if (ferror(f)) { /* 읽기 도중 오류 */ }

fclose(f);

바이너리 읽기 — 통째로

FILE* f = fopen("blob.bin", "rb");   // ⚠ 윈도우에서 "b" 는 필수
if (!f) return -1;

fseek(f, 0, SEEK_END);
long size = ftell(f);                // 2GB 넘으면 부족합니다
if (size < 0) { fclose(f); return -1; }   // ftell 실패는 -1
fseek(f, 0, SEEK_SET);

unsigned char* buf = malloc((size_t)size);
if (!buf) { fclose(f); return -1; }
size_t got = fread(buf, 1, (size_t)size, f);
if (got != (size_t)size) { /* 짧게 읽힘 */ }

fclose(f);
free(buf);

큰 파일에는 fseeko/ftello(POSIX) 또는 메모리 매핑(mmap·CreateFileMapping)을 씁니다.

반환값 규약을 하나로

프로젝트 안에서 "0 성공 · 음수 에러" 처럼 한 가지로 통일하세요. 어떤 함수는 0 이 성공이고 어떤 함수는 0 이 실패면 호출부에서 반드시 헷갈립니다.

부분 읽기 · 부분 쓰기

read/write(POSIX)는 요청한 만큼 다 처리하지 않을 수 있습니다. 소켓과 파이프에서 특히 그렇습니다 — 루프로 감싸는 것이 기본입니다.

경로와 인코딩

윈도우에서 한글 경로는 fopen 으로 안 열릴 수 있습니다. _wfopen 을 쓰거나 UTF-8 매니페스트를 켜야 합니다 — 크로스 플랫폼 코드에서 자주 만나는 함정입니다.

매크로가 무는 세 가지

// ① 괄호 누락
#define SQ(x) x * x
SQ(1 + 2)        // → 1 + 2 * 1 + 2  = 5  (9 가 아닙니다)
#define SQ(x) ((x) * (x))            // ✅ 전부 괄호로

// ② 인자를 두 번 평가
#define MAX(a,b) ((a) > (b) ? (a) : (b))
MAX(i++, j)      // i 가 두 번 증가할 수 있습니다

// ③ 여러 문장을 한 덩어리로
#define LOG(m) printf("%s", m); fflush(stdout)
if (x) LOG("hi");    // fflush 는 if 밖에서 항상 실행됩니다!

#define LOG(m) do { printf("%s", m); fflush(stdout); } while (0)

그래도 매크로가 필요한 자리

// 파일 · 줄 번호가 필요한 로깅 — 함수로는 불가능합니다
#define LOG_ERR(fmt, ...) \
    fprintf(stderr, "[%s:%d] " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)

// 배열 길이 (배열에만 써야 합니다 — 포인터에 쓰면 틀립니다)
#define COUNT_OF(a) (sizeof(a) / sizeof((a)[0]))

// 조건부 컴파일
#ifdef NDEBUG
#  define DBG(...) ((void)0)
#else
#  define DBG(...) LOG_ERR(__VA_ARGS__)
#endif

// 인클루드 가드 — 모든 헤더의 첫 줄
#ifndef MYLIB_BUFFER_H
#define MYLIB_BUFFER_H
/* ... */
#endif

자주 쓰는 미리 정의된 매크로

C++ 에서도 부를 수 있는 헤더 만들기

#ifndef MYLIB_H
#define MYLIB_H

#ifdef __cplusplus
extern "C" {
#endif

int mylib_add(int a, int b);
void mylib_free(char* p);

#ifdef __cplusplus
}
#endif

#endif  /* MYLIB_H */

전역 변수를 여러 파일에서 쓰기

/* config.h — 선언만 */
extern int g_verbose;          // "어딘가에 있다"

/* config.c — 정의는 딱 한 번 */
int g_verbose = 0;

/* main.c */
#include "config.h"
int main(void) { g_verbose = 1; }

가장 단순한 Makefile

CC      = gcc
CFLAGS  = -std=c17 -Wall -Wextra -g -O2
OBJS    = main.o buffer.o config.o

app: $(OBJS)
	$(CC) $(CFLAGS) -o $@ $(OBJS)

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJS) app

들여쓰기는 반드시 탭이어야 합니다 — 스페이스를 쓰면 "missing separator" 에러가 납니다. Make 의 대표적인 첫 관문입니다.

헤더 의존성 — 안 잡으면 반드시 물립니다

# 헤더를 고쳤는데 다시 빌드가 안 되는 문제를 막습니다
CFLAGS += -MMD -MP
-include $(OBJS:.o=.d)

이 두 줄이 없으면 헤더를 고쳐도 .o 가 그대로 남아 "고쳤는데 왜 안 바뀌지"가 반복됩니다. 실무에서는 이런 것을 알아서 처리하는 CMake 를 쓰는 편이 낫습니다(빌드 탭 참고).

공개 API 를 설계하는 규칙

• 공개 함수는 전부 같은 접두사로 (mylib_) — C 에는 네임스페이스가 없습니다
• 내부용 함수·변수는 전부 static
• 구조체 내용은 가능하면 헤더에 노출하지 않기(불투명 포인터)
• 헤더는 스스로 포함 가능해야 합니다 — 필요한 헤더를 자기가 포함
• 헤더에서 <stdio.h> 같은 큰 헤더를 불필요하게 포함하지 않기

나머지 두 가지 — 덜 알려졌지만 자주 밟습니다

// ⑤ 엄격한 앨리어싱 — 다른 타입 포인터로 같은 메모리 읽기
float f = 1.0f;
int   i = *(int*)&f;          // ❌ UB (-O2 에서 이상해집니다)

uint32_t bits;
memcpy(&bits, &f, sizeof bits);   // ✅ memcpy 는 항상 안전합니다

// ⑥ 한 식 안에서 같은 변수를 두 번 바꾸기
i = i++ + 1;                  // ❌ UB
arr[i] = i++;                 // ❌ UB
printf("%d %d", i++, i++);    // ❌ 인자 평가 순서도 정해져 있지 않습니다

memcpy 는 최적화 단계에서 대개 사라집니다. "느릴 것 같아서" 포인터 캐스팅을 쓸 이유가 없습니다.

방어하는 방법 — 도구가 전부입니다

C 헤더를 C++ 에서도 쓰이게 만들기

• extern "C" 가드를 반드시 넣습니다 (C 09 참고)
• C++ 예약어를 식별자로 쓰지 않습니다 — new, class, template, this, operator
• 구조체 태그와 typedef 이름을 같게 두면 양쪽에서 자연스럽습니다
• 가변 길이 배열(VLA)은 C++ 에 없습니다 — 공개 헤더에 쓰지 마세요
• restrict 는 C 전용입니다 — 매크로로 감싸 두세요

C 스타일이 C++ 에서 문제가 되는 것들

// ① malloc/free 로 C++ 객체를 다루면 생성자·소멸자가 안 불립니다
Widget* w = (Widget*)malloc(sizeof(Widget));   // ❌ 생성자 미호출
Widget* w = new Widget();                      // ✅

// ② memset 으로 클래스를 0 으로 미는 것
memset(&obj, 0, sizeof obj);   // ❌ vptr 까지 밀어 버립니다

// ③ C 캐스트는 무엇을 하는지 알 수 없습니다
(Derived*)base;                // ❌ 어떤 캐스트인지 불분명
static_cast<Derived*>(base);   // ✅ 의도가 드러납니다

// ④ 배열 대신 std::vector, 문자열 대신 std::string
//    C++ 에서 원시 배열을 쓸 이유는 거의 없습니다

C 로 쓰는 게 나은 경우

• 임베디드 · 부트로더 · 커널 모듈
• 여러 언어에서 부를 라이브러리의 경계
• C 로 된 기존 코드베이스에 얹는 코드
• 빌드 도구가 C++ 를 지원하지 않는 환경

C++ 로 쓰는 게 나은 경우

• 자원 관리가 복잡한 코드 — RAII 가 압도적
• 자료구조가 많이 필요한 코드 — STL
• 제네릭이 필요한 코드 — 템플릿
• 규모가 커질 코드 — 타입 시스템의 도움이 큽니다

실무에서 가장 흔한 절충

안은 C++ 로 쓰고, 밖으로 내보내는 경계만 C 로 만드는 방식입니다. RAII 와 STL 의 이득을 그대로 누리면서, 파이썬·Node·C#·Go 어디서든 부를 수 있는 .so·.dll 이 나옵니다.

가장 많이 쓰는 함수 — stdio · stdlib

string.h — 이름과 달리 절반이 메모리 함수

assert · errno · static_assert

#include <assert.h>
#include <errno.h>
#include <string.h>   // strerror

void put(int *arr, size_t n, size_t i, int v) {
    assert(arr != NULL);
    assert(i < n);          // 개발 중에만 검사됩니다
    arr[i] = v;
}
// NDEBUG 가 정의되면 assert 는 통째로 사라집니다:
//   gcc -DNDEBUG -O2 ...   ← 릴리스 빌드
// ★ 그래서 assert 안에 '부작용이 있는 식'을 넣으면 안 됩니다
//   assert(pop(&stack) == 3);   // 릴리스에서 pop 이 실행되지 않음!

// 컴파일 시점 검사 — C11 부터
#include <assert.h>
static_assert(sizeof(int) == 4, "이 코드는 32비트 int 를 가정합니다");

FILE *f = fopen("없는파일", "r");
if (!f) {
    // errno 는 '마지막 실패'를 담습니다. 성공한 호출도 값을 바꿀 수 있으니 실패 직후에만 봅니다
    int e = errno;          // 바로 저장 — 다음 호출(fprintf 포함)이 덮어쓸 수 있음
    fprintf(stderr, "열기 실패: %s (errno=%d)\n", strerror(e), e);
    // 또는 perror("fopen"); 한 줄로 — 단 다른 호출보다 먼저 불러야 합니다
}

난수 · 시간 · 환경변수

#include <stdlib.h>
#include <time.h>

// ① 난수 — rand() 는 품질이 낮습니다. 게임/시뮬레이션까지가 한계
srand((unsigned)time(NULL));      // 시드는 한 번만
int d = rand() % 6 + 1;           // ★ 모듈로 편향이 있지만 주사위 정도면 무방
// 암호용이라면 절대 rand() 를 쓰지 마세요:
//   리눅스 getrandom(), BSD/맥 arc4random_buf(), 윈도우 BCryptGenRandom()

// ② 실제 경과 시간 (clock 은 CPU 시간이라 sleep 을 못 셉니다)
struct timespec t0, t1;
timespec_get(&t0, TIME_UTC);      // C11 표준
/* ... 작업 ... */
timespec_get(&t1, TIME_UTC);
double ms = (t1.tv_sec - t0.tv_sec) * 1e3
          + (t1.tv_nsec - t0.tv_nsec) / 1e6;

// ③ 사람이 읽는 시각
time_t now = time(NULL);
struct tm tmv;
#if defined(_WIN32)
    localtime_s(&tmv, &now);
#else
    localtime_r(&now, &tmv);      // localtime() 은 스레드 안전하지 않습니다
#endif
char buf[64];
strftime(buf, sizeof buf, "%Y-%m-%d %H:%M:%S", &tmv);

// ④ 환경변수
const char *home = getenv("HOME");    // 없으면 NULL

① void* + 원소 크기 — 코드가 하나면 됩니다

typedef struct {
    void  *data;
    size_t len, cap, esz;   // esz = 원소 하나의 바이트 수
} GVec;

static void gvec_init(GVec *v, size_t esz) {
    v->data = NULL; v->len = v->cap = 0; v->esz = esz;
}

static int gvec_push(GVec *v, const void *item) {
    if (v->len == v->cap) {
        size_t cap = v->cap ? v->cap * 2 : 8;
        void *p = realloc(v->data, cap * v->esz);
        if (!p) return -1;
        v->data = p; v->cap = cap;
    }
    // 바이트 단위로 계산해야 하므로 char* 로 캐스트합니다
    memcpy((char *)v->data + v->len * v->esz, item, v->esz);
    v->len++;
    return 0;
}

#define GVEC_AT(v, T, i)  (((T *)(v)->data)[i])

// 사용
GVec v; gvec_init(&v, sizeof(double));
double x = 3.14;
gvec_push(&v, &x);                 // ★ 값이 아니라 주소를 넘깁니다
printf("%f\n", GVEC_AT(&v, double, 0));

② 매크로로 타입별 코드 찍어내기

// C++ 템플릿을 전처리기로 흉내 내는 방법입니다
#define VEC_DECLARE(T, name)                                   \
    typedef struct { T *data; size_t len, cap; } name;         \
    static inline void name##_init(name *v){                   \
        v->data=NULL; v->len=v->cap=0; }                       \
    static inline int name##_push(name *v, T x){               \
        if (v->len == v->cap) {                                \
            size_t c = v->cap ? v->cap*2 : 8;                  \
            T *p = realloc(v->data, c*sizeof(T));              \
            if (!p) return -1;                                 \
            v->data = p; v->cap = c; }                         \
        v->data[v->len++] = x; return 0; }                     \
    static inline void name##_free(name *v){                   \
        free(v->data); v->data=NULL; v->len=v->cap=0; }

VEC_DECLARE(int,    IntVec)
VEC_DECLARE(double, DblVec)

IntVec a; IntVec_init(&a); IntVec_push(&a, 7);
// a.data[0] 은 진짜 int* — 타입 검사가 살아 있습니다

해시 DoS — 외부 입력이 키가 될 때

// 공격자가 '해시가 전부 같은 키'를 골라 보내면
// 모든 항목이 한 슬롯에 몰려 O(n) 이 됩니다.
// HTTP 헤더·JSON 키·쿼리 파라미터가 대표적인 통로입니다.

// 대응 ① 프로세스마다 무작위 시드를 섞습니다
static uint64_t g_seed;   // 시작할 때 난수로 채움

static uint64_t fnv1a_seeded(const char *s) {
    uint64_t h = 14695981039346656037ULL ^ g_seed;
    while (*s) { h ^= (unsigned char)*s++; h *= 1099511628211ULL; }
    return h;
}

// 대응 ② 키가 신뢰할 수 없는 입력이면 SipHash 를 씁니다
//   — 파이썬 3.4+, 러스트 HashMap, 리눅스 커널이 쓰는 방식
//   구현이 짧아(200줄) 그대로 넣어 쓸 수 있습니다

가져다 쓰는 편이 나은 경우

// stb_ds.h — 한 파일만 받아서 넣으면 끝
#define STB_DS_IMPLEMENTATION
#include "stb_ds.h"

int *nums = NULL;
arrput(nums, 10);              // 동적 배열
arrput(nums, 20);
printf("%zu개, 첫 값 %d\n", arrlen(nums), nums[0]);
arrfree(nums);

struct { char *key; int value; } *dict = NULL;
shput(dict, "apple", 3);       // 문자열 키 해시맵
printf("%d\n", shget(dict, "apple"));
shfree(dict);

한 줄 읽어 CSV 로 자르기 — 안전한 방법

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>      // errno · ERANGE

// "kim,31,seoul\n" 같은 줄을 필드로 자릅니다
void parse_line(char *line) {
    // ① 끝의 개행 제거 — fgets 는 '\n' 을 남깁니다
    line[strcspn(line, "\r\n")] = '\0';   // ★ 관용구. 개행이 없어도 안전

    // ② strtok_r — 상태를 saveptr 에 두므로 스레드 안전
    char *save = NULL;
    char *name = strtok_r(line, ",", &save);
    char *ages = strtok_r(NULL, ",", &save);   // ★ 두 번째부터는 NULL
    char *city = strtok_r(NULL, ",", &save);
    if (!name || !ages || !city) {            // 필드가 모자라면
        fprintf(stderr, "형식 오류\n");
        return;
    }

    // ③ 숫자 변환 — 실패를 알 수 있는 방법
    char *end;
    errno = 0;
    long age = strtol(ages, &end, 10);
    if (end == ages || *end != '\0' || errno == ERANGE) {
        fprintf(stderr, "나이가 숫자가 아닙니다: %s\n", ages);
        return;
    }
    printf("%s / %ld / %s\n", name, age, city);
}

int main(void) {
    char buf[512];
    while (fgets(buf, sizeof buf, stdin))   // ★ sizeof buf 로 크기를 넘김
        parse_line(buf);
}

해서는 안 되는 것들 — 실제 사고 목록

char buf[64];
gets(buf);              // C11 에서 삭제됨. 무조건 금지
scanf("%s", buf);       // 길이 제한 없음 → 오버플로
strcpy(buf, argv[1]);   // 인자가 길면 그대로 넘침
sprintf(buf, "%s/%s", dir, file);   // 같은 문제

int n = atoi(argv[1]);  // 실패해도 0. 구분 불가
char *p = strtok(s, ","); // 전역 상태 · 원본 파괴

char buf[64];
fgets(buf, sizeof buf, stdin);
scanf("%63s", buf);     // ★ 크기-1 을 반드시 명시

snprintf(buf, sizeof buf, "%s", argv[1]);
int need = snprintf(buf, sizeof buf, "%s/%s", dir, file);
if (need >= (int)sizeof buf)
    fprintf(stderr, "경로가 잘렸습니다\n");   // ★ 반환값 확인

long n = strtol(argv[1], &end, 10);
char *p = strtok_r(s, ",", &save);

글자 수 세기 · 안전하게 자르기

#include <stddef.h>
#include <stdbool.h>
#include <string.h>     // strlen

// 뒤따르는 바이트는 상위 두 비트가 10 입니다 (0x80~0xBF)
static bool is_cont(unsigned char c) { return (c & 0xC0) == 0x80; }

// 글자 수 = 뒤따르지 않는 바이트의 개수
size_t utf8_len(const char *s) {
    size_t n = 0;
    for (const unsigned char *p = (const unsigned char *)s; *p; p++)
        if (!is_cont(*p)) n++;
    return n;
}

// 글자 단위로 안전하게 자르기 — 최대 max 바이트 안에서
// 글자 중간이 잘리지 않는 위치를 돌려줍니다
size_t utf8_trunc(const char *s, size_t max) {
    size_t n = strlen(s);
    if (n <= max) return n;
    size_t cut = max;
    while (cut > 0 && is_cont((unsigned char)s[cut])) cut--;
    return cut;
}

// 코드포인트 하나를 읽고 다음 위치로 이동
const char *utf8_next(const char *s, unsigned *out) {
    unsigned char c = (unsigned char)*s;
    int extra = c < 0x80 ? 0 : c < 0xE0 ? 1 : c < 0xF0 ? 2 : 3;
    unsigned cp = c & (0xFF >> (extra + 2));
    if (extra == 0) cp = c;
    for (int i = 0; i < extra; i++)
        cp = (cp << 6) | (*++s & 0x3F);
    *out = cp;
    return s + 1;
}

윈도우 콘솔과 파일 경로 — 최대 함정

// 리눅스·맥: 파일 경로도 소스도 전부 UTF-8. 신경 쓸 것 없음
// 윈도우: 기본 코드 페이지가 UTF-8 이 아닐 수 있습니다

#ifdef _WIN32
#include <windows.h>
static void setup_console(void) {
    SetConsoleOutputCP(CP_UTF8);   // 출력 코드 페이지를 UTF-8 로
    SetConsoleCP(CP_UTF8);         // 입력도
}
#else
static void setup_console(void) { }
#endif

int main(void) {
    setup_console();
    printf("한글이 깨지지 않습니다\n");
}

// 파일 경로에 한글이 있으면 윈도우에서는 fopen 이 실패할 수 있습니다.
// 방법 ① 실행 파일에 UTF-8 매니페스트를 넣습니다 (Win10 1903+)
// 방법 ② _wfopen 과 MultiByteToWideChar 로 UTF-16 을 씁니다
// 방법 ③ MSVC 라면 /utf-8 플래그로 소스 인코딩을 못박습니다

open · read · write — 시스템 콜 직접 쓰기

#include <fcntl.h>      // open, O_RDONLY
#include <unistd.h>     // read, write, close
#include <errno.h>
#include <string.h>

int copy_file(const char *src, const char *dst) {
    int in = open(src, O_RDONLY);
    if (in < 0) return -1;                      // ★ 실패는 -1, errno 에 이유

    int out = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (out < 0) { close(in); return -1; }

    char buf[65536];
    ssize_t n;
    while ((n = read(in, buf, sizeof buf)) > 0) {
        ssize_t off = 0;
        while (off < n) {
            // ★ write 는 요청한 만큼 다 안 쓸 수 있습니다 (부분 쓰기)
            ssize_t w = write(out, buf + off, (size_t)(n - off));
            if (w < 0) {
                if (errno == EINTR) continue;   // ★ 시그널에 끊긴 것뿐
                close(in); close(out); return -1;
            }
            off += w;
        }
    }
    int rc = (n < 0) ? -1 : 0;
    close(in);
    if (close(out) < 0) rc = -1;   // ★ close 실패도 데이터 유실입니다
    return rc;
}

stat · 디렉터리 순회

#include <sys/stat.h>
#include <dirent.h>
#include <stdio.h>
#include <string.h>     // strcmp
#include <time.h>

void list_dir(const char *path) {
    DIR *d = opendir(path);
    if (!d) { perror("opendir"); return; }

    struct dirent *e;
    while ((e = readdir(d)) != NULL) {
        if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, ".."))
            continue;

        char full[4096];
        snprintf(full, sizeof full, "%s/%s", path, e->d_name);

        struct stat st;
        if (stat(full, &st) != 0) continue;     // 심볼릭 링크가 깨졌을 수도

        char when[32];
        struct tm tmv;
        localtime_r(&st.st_mtime, &tmv);
        strftime(when, sizeof when, "%Y-%m-%d %H:%M", &tmv);

        printf("%c %10lld  %s  %s\n",
               S_ISDIR(st.st_mode) ? 'd' : '-',   // 종류
               (long long)st.st_size,             // 크기
               when, e->d_name);
    }
    closedir(d);
}

어떤 시계를 써야 하나

#include <time.h>

// ① 경과 시간 측정 — 반드시 MONOTONIC
//    시스템 시계가 NTP 로 뒤로 점프해도 영향받지 않습니다
struct timespec t0, t1;
clock_gettime(CLOCK_MONOTONIC, &t0);
/* ... 작업 ... */
clock_gettime(CLOCK_MONOTONIC, &t1);
double sec = (t1.tv_sec - t0.tv_sec)
           + (t1.tv_nsec - t0.tv_nsec) / 1e9;

// ② '지금 몇 시인가' — REALTIME (벽시계)
clock_gettime(CLOCK_REALTIME, &t0);

// ③ 이 스레드가 실제로 CPU 를 쓴 시간
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &t0);

// ④ 잠깐 자기 (EINTR 을 견디는 형태)
struct timespec req = { .tv_sec = 0, .tv_nsec = 200000000 }; // 0.2초
while (nanosleep(&req, &req) == -1 && errno == EINTR) { }

POSIX ↔ Win32 대응표와 분기 관용구

// 얇은 이식 계층을 하나 만들어 두는 것이 정석입니다
#ifdef _WIN32
  #include <windows.h>
  static double now_sec(void) {
      LARGE_INTEGER f, c;
      QueryPerformanceFrequency(&f);
      QueryPerformanceCounter(&c);
      return (double)c.QuadPart / (double)f.QuadPart;
  }
  static void sleep_ms(int ms) { Sleep((DWORD)ms); }
#else
  #include <time.h>
  static double now_sec(void) {
      struct timespec t;
      clock_gettime(CLOCK_MONOTONIC, &t);
      return t.tv_sec + t.tv_nsec / 1e9;
  }
  static void sleep_ms(int ms) {
      struct timespec r = { ms / 1000, (long)(ms % 1000) * 1000000L };
      nanosleep(&r, NULL);
  }
#endif
// ★ 나머지 코드는 now_sec / sleep_ms 만 부릅니다 — #ifdef 가 번지지 않게

클라이언트 — 이름 해석까지 제대로

// getaddrinfo 는 IPv4/IPv6 를 자동으로 처리합니다
// (inet_addr 은 IPv4 전용 + 낡았습니다 — 쓰지 마세요)
struct addrinfo hints, *res, *it;
memset(&hints, 0, sizeof hints);
hints.ai_family   = AF_UNSPEC;      // v4 든 v6 든
hints.ai_socktype = SOCK_STREAM;

if (getaddrinfo("127.0.0.1", "9000", &hints, &res) != 0) return 1;

sock_t fd = INVALID_SOCKET;
for (it = res; it; it = it->ai_next) {       // ★ 후보를 순서대로 시도
    fd = socket(it->ai_family, it->ai_socktype, it->ai_protocol);
    if (fd == INVALID_SOCKET) continue;
    if (connect(fd, it->ai_addr, (int)it->ai_addrlen) == 0) break;
    CLOSESOCK(fd);
    fd = INVALID_SOCKET;
}
freeaddrinfo(res);
if (fd == INVALID_SOCKET) { fprintf(stderr, "접속 실패\n"); return 1; }

const char *msg = "안녕 서버\n";
send(fd, msg, (int)strlen(msg), 0);

char buf[4096];
int n = recv(fd, buf, sizeof buf - 1, 0);
if (n > 0) { buf[n] = '\0'; printf("에코: %s", buf); }
CLOSESOCK(fd);

TCP 는 스트림입니다 — 메시지 경계가 없습니다 ★

// send 를 세 번 했다고 recv 가 세 번 나뉘어 오지 않습니다.
// 한 번에 뭉쳐 올 수도, 한 번이 여러 번에 나뉘어 올 수도 있습니다.
//   → '어디까지가 한 메시지인지'는 내가 정해야 합니다

// 방법 ① 길이 접두사 (가장 흔하고 안전)
int send_msg(sock_t fd, const void *p, uint32_t len) {
    uint32_t be = htonl(len);                 // 4바이트 길이 먼저
    if (send_all(fd, &be, 4) != 0) return -1;
    return send_all(fd, p, len);
}

int recv_msg(sock_t fd, char *out, uint32_t max, uint32_t *got) {
    uint32_t be;
    if (recv_all(fd, &be, 4) != 0) return -1;
    uint32_t len = ntohl(be);
    if (len > max) return -1;                 // ★ 길이 검증 필수(메모리 폭탄 방지)
    if (recv_all(fd, out, len) != 0) return -1;
    *got = len;
    return 0;
}

// 방법 ② 구분자 — 줄바꿈까지 읽기 (HTTP · Redis 프로토콜 방식)
// 방법 ③ 고정 길이 레코드 — 가장 단순하지만 확장이 어렵습니다

pthreads — 리눅스·맥의 사실상 표준

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

typedef struct { int from, to; long sum; } Job;

// 스레드 함수의 모양은 고정입니다: void* (*)(void*)
static void *worker(void *arg) {
    Job *j = arg;
    long s = 0;
    for (int i = j->from; i < j->to; i++) s += i;
    j->sum = s;                 // ★ 각자 다른 Job 을 쓰므로 레이스 없음
    return NULL;
}

int main(void) {
    enum { N = 4 };
    pthread_t th[N];
    Job jobs[N];

    for (int i = 0; i < N; i++) {
        jobs[i] = (Job){ i * 250000, (i + 1) * 250000, 0 };
        if (pthread_create(&th[i], NULL, worker, &jobs[i]) != 0) {
            perror("pthread_create"); return 1;
        }
    }
    long total = 0;
    for (int i = 0; i < N; i++) {
        pthread_join(th[i], NULL);   // ★ 끝날 때까지 기다립니다
        total += jobs[i].sum;
    }
    printf("합계 %ld\n", total);
}
// 컴파일: gcc -std=c17 -O2 -pthread sum.c -o sum

C11 <threads.h> — 표준이지만 현실은

#include <threads.h>
#include <stdio.h>

static int worker(void *arg) {     // ★ 반환형이 int (pthreads 는 void*)
    printf("스레드 %d\n", *(int *)arg);
    return 0;
}

int main(void) {
    thrd_t t;
    int id = 7;
    if (thrd_create(&t, worker, &id) != thrd_success) return 1;
    thrd_join(t, NULL);

    mtx_t m;  mtx_init(&m, mtx_plain);
    mtx_lock(&m);  /* 임계 구역 */  mtx_unlock(&m);
    mtx_destroy(&m);
}

stdatomic.h — 뮤텍스 없이 안전하게

#include <stdatomic.h>

atomic_long counter = 0;

void *bump(void *_) {
    for (int i = 0; i < 1000000; i++)
        atomic_fetch_add(&counter, 1);   // ★ 읽기+더하기+쓰기가 한 동작
    return NULL;
}
// 뮤텍스보다 훨씬 빠릅니다 — 커널에 들어가지 않으니까요

// 플래그 하나로 스레드 멈추기 (가장 흔한 용도)
atomic_bool stop = false;

void *loop(void *_) {
    while (!atomic_load_explicit(&stop, memory_order_relaxed)) {
        /* 일 */
    }
    return NULL;
}
// 다른 스레드에서:
atomic_store(&stop, true);

// 락 없는 스택 push — CAS(compare-and-swap) 관용구
void push(_Atomic(Node *) *head, Node *n) {
    Node *old = atomic_load(head);
    do {
        n->next = old;
    } while (!atomic_compare_exchange_weak(head, &old, n));
    // ★ 실패하면 old 가 '현재 값'으로 갱신되어 다시 시도합니다
}

ThreadSanitizer — 실제로 잡아 봅니다

# 레이스가 있는 코드를 일부러 만들어 보세요
gcc -std=c17 -g -O1 -fsanitize=thread -pthread race.c -o race
./race

WARNING: ThreadSanitizer: data race (pid=12345)
  Write of size 8 at 0x55d1e8 by thread T2:
    #0 bump race.c:12 (race+0x1220)

  Previous write of size 8 at 0x55d1e8 by thread T1:
    #0 bump race.c:12 (race+0x1220)

  Location is global 'counter' of size 8 at 0x55d1e8

SUMMARY: ThreadSanitizer: data race race.c:12 in bump

fork + exec + wait — 외부 명령 실행하기

#include <unistd.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>

int run(char *const argv[]) {
    pid_t pid = fork();
    if (pid < 0) { perror("fork"); return -1; }

    if (pid == 0) {                       // ── 자식 ──
        execvp(argv[0], argv);            // 성공하면 여기로 안 돌아옵니다
        perror("execvp");                 // 여기 왔다는 건 실패했다는 뜻
        _exit(127);                       // ★ exit 이 아니라 _exit
    }

    // ── 부모 ──
    int status;
    while (waitpid(pid, &status, 0) < 0)
        if (errno != EINTR) return -1;

    if (WIFEXITED(status))   return WEXITSTATUS(status);   // 정상 종료 코드
    if (WIFSIGNALED(status)) return 128 + WTERMSIG(status); // 시그널로 죽음
    return -1;
}

int main(void) {
    char *cmd[] = { "ls", "-l", NULL };   // ★ 마지막은 반드시 NULL
    printf("종료 코드 %d\n", run(cmd));
}

파이프로 자식의 출력을 받아 오기

// 간단하게: popen — 셸을 거칩니다
FILE *p = popen("git rev-parse HEAD", "r");
if (p) {
    char line[128];
    if (fgets(line, sizeof line, p)) printf("커밋 %s", line);
    int rc = pclose(p);     // ★ 반드시 pclose (종료 코드도 여기서)
}
// ⚠ popen 은 문자열을 셸에 넘깁니다 —
//   사용자 입력을 그대로 넣으면 명령 주입 취약점이 됩니다

// 정확하게: pipe + fork (셸을 안 거칩니다)
int fd[2];
if (pipe(fd) != 0) return -1;       // fd[0]=읽기, fd[1]=쓰기

pid_t pid = fork();
if (pid == 0) {
    close(fd[0]);                   // ★ 안 쓰는 쪽은 반드시 닫습니다
    dup2(fd[1], STDOUT_FILENO);     // 표준 출력을 파이프로 바꿔치기
    close(fd[1]);
    execlp("ls", "ls", "-l", (char *)NULL);
    _exit(127);
}
close(fd[1]);                       // 부모도 쓰기 쪽을 닫아야
char buf[4096];                     // 자식이 끝날 때 EOF 가 옵니다
ssize_t n;
while ((n = read(fd[0], buf, sizeof buf)) > 0)
    fwrite(buf, 1, (size_t)n, stdout);
close(fd[0]);
waitpid(pid, NULL, 0);

CreateProcess — fork+exec 이 한 함수

#include <windows.h>
#include <stdio.h>

int run_win(const char *cmdline) {
    STARTUPINFOA si;  PROCESS_INFORMATION pi;
    ZeroMemory(&si, sizeof si);  si.cb = sizeof si;
    ZeroMemory(&pi, sizeof pi);

    // ★ cmdline 은 쓰기 가능한 버퍼여야 합니다 (API 가 수정합니다)
    char buf[1024];
    snprintf(buf, sizeof buf, "%s", cmdline);

    if (!CreateProcessA(NULL, buf, NULL, NULL, FALSE,
                        0, NULL, NULL, &si, &pi)) {
        fprintf(stderr, "CreateProcess 실패 %lu\n", GetLastError());
        return -1;
    }
    WaitForSingleObject(pi.hProcess, INFINITE);   // wait() 에 해당

    DWORD code = 0;
    GetExitCodeProcess(pi.hProcess, &code);
    CloseHandle(pi.hProcess);                     // ★ 핸들 누수 주의
    CloseHandle(pi.hThread);
    return (int)code;
}

대응표와 실무 선택

바로 편해지는 것들

// ① nullptr — NULL 의 모호함이 사라집니다
void f(int);
void f_ptr(char *);
char *p = nullptr;          // 타입이 nullptr_t 로 확실합니다
// 예전에는 NULL 이 0 일 수도 (void*)0 일 수도 있어
// 가변 인자로 넘길 때 크기가 어긋나는 사고가 있었습니다
execl("/bin/ls", "ls", nullptr);   // ★ (char*)NULL 안 써도 됩니다

// ② bool 이 키워드가 됐습니다 — stdbool.h 불필요
bool ok = true;

// ③ 2진 리터럴 + 자릿수 구분자
unsigned mask  = 0b1010'1010;      // 비트 마스크가 눈에 보입니다
unsigned flags = 0b0000'0001;

// ④ auto — 타입 추론 (C++ 의 그것과 같습니다)
auto n = 42;                       // int
auto s = "hi";                     // char* (C 의 문자열 리터럴은 const 가 아님)
// 매크로 안에서 임시 변수를 만들 때 특히 유용합니다

// ⑤ typeof / typeof_unqual — GCC 확장이 표준이 됐습니다
#define SWAP(a, b) do { typeof(a) _t = (a); (a) = (b); (b) = _t; } while (0)

// ⑥ 열거형의 밑바탕 타입 지정
enum Color : unsigned char { RED, GREEN, BLUE };   // 1바이트 확정

구조를 바꾸는 것들

// ① constexpr — 진짜 컴파일 시점 상수
constexpr int MAX = 1024;
int arr[MAX];               // enum 이나 #define 을 안 써도 됩니다
// (C++ 과 달리 C23 의 constexpr 은 '객체'에만 붙습니다. 함수는 아직 없습니다)

// ② #embed — 파일을 배열로 바로 넣기 ★
const unsigned char icon[] = {
    #embed "logo.png"
};
// 예전에는 xxd -i 로 헤더를 생성해 빌드에 끼워 넣었습니다.
// 폰트·셰이더·인증서를 실행 파일에 박을 때 압도적으로 편합니다

// ③ _BitInt(N) — 원하는 비트 수의 정수
_BitInt(24)  pixel;         // 정확히 24비트
unsigned _BitInt(3) tiny;   // 0~7
// 하드웨어 레지스터·비트 프로토콜을 다룰 때 유용합니다

// ④ [[attributes]] — C++ 문법이 그대로
[[nodiscard]] int must_check(void);
[[deprecated("v2 에서 제거됩니다")]] void old_api(void);
[[maybe_unused]] static int debug_only;
[[fallthrough]];            // switch 에서 의도적 관통 표시

// ⑤ 표준에 들어온 함수들
memset_explicit(key, 0, len);   // 최적화가 지우지 못하게 (비밀 삭제)
// strdup / strndup 도 드디어 표준이 됐습니다

여전히 그대로인 것들

// GCC/Clang 확장이지만 실무에서 아주 유용한 것 — 자동 정리
static inline void free_ptr(void *p) { free(*(void **)p); }
#define AUTOFREE __attribute__((cleanup(free_ptr)))

void f(void) {
    AUTOFREE char *buf = malloc(1024);
    if (!buf) return;
    /* ... 중간에 어디서 return 해도 ... */
}   // ★ 스코프를 벗어날 때 자동으로 free 됩니다 (C++ 의 RAII 흉내)
// 표준은 아니지만 GCC·Clang 양쪽에서 되고, systemd 가 전면적으로 씁니다

_Generic — C 의 함수 오버로딩

// C11 부터 있던 기능인데 잘 안 알려져 있습니다
#include <math.h>

#define abs_any(x) _Generic((x),          \
        int:    abs,                      \
        long:   labs,                     \
        float:  fabsf,                    \
        double: fabs                      \
    )(x)

printf("%d %f\n", abs_any(-3), abs_any(-3.5));

// 타입에 따라 다른 출력 서식을 고르기
#define fmt_of(x) _Generic((x),           \
        int:         "%d",                \
        unsigned:    "%u",                \
        long long:   "%lld",              \
        double:      "%f",                \
        char *:      "%s",                \
        default:     "%p")

#define print_any(x) printf(fmt_of(x) "\n", (x))
print_any(42);        // %d
print_any("hello");   // %s

volatile — 여기서가 진짜 쓰임새입니다

// 하드웨어 레지스터는 '내가 안 바꿔도 값이 변합니다'
// volatile 이 없으면 컴파일러가 두 번째 읽기를 생략해 버립니다

#define UART0_BASE  0x40011000u
#define UART_SR     (*(volatile uint32_t *)(UART0_BASE + 0x00))
#define UART_DR     (*(volatile uint32_t *)(UART0_BASE + 0x04))
#define SR_TXE      (1u << 7)   // 송신 버퍼 빔

void uart_putc(char c) {
    while (!(UART_SR & SR_TXE)) { }   // ★ volatile 이 없으면 무한 루프
    UART_DR = (uint32_t)(unsigned char)c;
}

// volatile 이 하는 일 / 하지 않는 일
//   ○ 매번 실제로 메모리를 읽고 씁니다 (최적화로 생략 안 됨)
//   ○ volatile 접근끼리의 순서를 유지합니다
//   ✕ 원자성을 보장하지 않습니다      → 스레드에는 _Atomic (c19)
//   ✕ CPU 재배치·캐시 일관성과 무관   → 배리어가 따로 필요

// 인터럽트 핸들러와 공유하는 변수에는 붙입니다
static volatile uint32_t g_ticks;      // 타이머 ISR 이 증가시킴

void SysTick_Handler(void) { g_ticks++; }   // 인터럽트에서
void delay_ms(uint32_t ms) {
    uint32_t start = g_ticks;
    while (g_ticks - start < ms) { }         // ★ 뺄셈이라 오버플로에도 안전
}

비트 연산 — 레지스터를 다루는 문법

#include <stdint.h>

#define BIT(n)            (1u << (n))
#define SET_BIT(r, m)     ((r) |=  (m))
#define CLR_BIT(r, m)     ((r) &= ~(m))
#define TGL_BIT(r, m)     ((r) ^=  (m))
#define GET_BIT(r, m)     (((r) & (m)) != 0)

// 여러 비트로 된 필드 쓰기 — 읽고, 지우고, 넣기 (read-modify-write)
#define FIELD(r, mask, shift, v) \
    ((r) = ((r) & ~(mask)) | (((uint32_t)(v) << (shift)) & (mask)))

// GPIO 예: 5번 핀을 출력으로 설정하고 켜기
#define GPIOA_MODER (*(volatile uint32_t *)0x40020000u)
#define GPIOA_ODR   (*(volatile uint32_t *)0x40020014u)

FIELD(GPIOA_MODER, 0x3u << 10, 10, 0b01);  // 5번 핀 모드 = 출력
SET_BIT(GPIOA_ODR, BIT(5));                // 5번 핀 HIGH
CLR_BIT(GPIOA_ODR, BIT(5));                // 5번 핀 LOW

// 자주 쓰는 비트 요령
uint32_t x = 0b1011'0000;
int lowest = x & -x;              // 가장 낮은 1 비트만 남기기
int count  = __builtin_popcount(x);   // 1 비트 개수 (GCC/Clang)
int lead   = __builtin_clz(x);        // 앞쪽 0 개수 → 로그2 계산에
x &= x - 1;                       // 가장 낮은 1 비트 지우기

-ffreestanding 이 무엇을 바꾸나

# 호스티드(hosted) — 우리가 지금까지 쓴 환경
#   main 이 시작점 · 표준 라이브러리 전부 사용 가능
gcc main.c -o app

# 프리스탠딩(freestanding) — OS 도 libc 도 없음
arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb \
  -ffreestanding -nostdlib -nostartfiles \
  -T linker.ld -Wl,-Map=out.map \
  startup.c main.c -o firmware.elf

arm-none-eabi-objcopy -O binary firmware.elf firmware.bin
arm-none-eabi-size firmware.elf     # ROM/RAM 사용량 확인

프리스탠딩에서 쓸 수 있는 표준 헤더는 이것뿐입니다:
  <stddef.h> <stdint.h> <stdbool.h> <limits.h>
  <float.h> <stdarg.h> <iso646.h> <stdalign.h> <stdnoreturn.h>

없는 것: printf, malloc, 파일, 문자열 함수 일부
  → printf 는 UART 로 내보내는 미니 버전을 직접 만들거나
    nanoprintf 같은 단일 헤더 구현을 넣습니다

링커 스크립트 맛보기

/* linker.ld — 메모리 어디에 무엇을 놓을지 정합니다 */
MEMORY {
  FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 512K
  RAM  (rwx) : ORIGIN = 0x20000000, LENGTH = 128K
}

SECTIONS {
  .text : {           /* 코드와 상수 — 플래시에 */
    KEEP(*(.isr_vector))   /* ★ 인터럽트 벡터는 맨 앞에 고정 */
    *(.text*)
    *(.rodata*)
  } > FLASH

  .data : {           /* 초기값 있는 전역 — RAM 에서 실행, 플래시에 원본 */
    _sdata = .;
    *(.data*)
    _edata = .;
  } > RAM AT > FLASH
  _sidata = LOADADDR(.data);   /* 플래시에 있는 .data 원본의 주소 — startup 이 씀 */

  .bss : {            /* 0으로 시작하는 전역 — RAM 만 차지 */
    _sbss = .;
    *(.bss*) *(COMMON)
    _ebss = .;
  } > RAM
}

/* startup.c — main 보다 먼저 도는 코드 */
extern uint32_t _sdata, _edata, _sbss, _ebss, _sidata;

void Reset_Handler(void) {
    // ① 초기값 있는 전역을 플래시에서 RAM 으로 복사
    uint32_t *src = &_sidata, *dst = &_sdata;
    while (dst < &_edata) *dst++ = *src++;

    // ② .bss 를 0 으로 (C 표준이 약속한 것)
    for (dst = &_sbss; dst < &_ebss; dst++) *dst = 0;

    main();                 // ★ 이제야 C 코드가 정상 동작합니다
    for (;;) { }
}

파이썬 · C#

# 파이썬 — 표준 라이브러리 ctypes 만으로 됩니다
import ctypes, platform

name = "mathlib.dll" if platform.system() == "Windows" else "./libmathlib.so"
lib = ctypes.CDLL(name)

lib.ml_add.argtypes = [ctypes.c_int, ctypes.c_int]   # ★ 반드시 명시
lib.ml_add.restype  = ctypes.c_int
print(lib.ml_add(2, 3))            # 5

lib.ml_mean.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_size_t]
lib.ml_mean.restype  = ctypes.c_double
arr = (ctypes.c_double * 4)(1.0, 2.0, 3.0, 4.0)
print(lib.ml_mean(arr, 4))         # 2.5

lib.ml_version.restype = ctypes.c_char_p
print(lib.ml_version().decode())   # 1.2.0

// C# — P/Invoke
using System.Runtime.InteropServices;

internal static partial class Native {
    [LibraryImport("mathlib")]            // .NET 7+ 소스 생성 방식
    internal static partial int ml_add(int a, int b);
}
Console.WriteLine(Native.ml_add(2, 3));

자바 (FFM) · Node · 러스트

// 자바 21+ — Foreign Function & Memory API (JNI 없이)
import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;

try (Arena arena = Arena.ofConfined()) {
    SymbolLookup lib = SymbolLookup.libraryLookup("mathlib", arena);
    MethodHandle add = Linker.nativeLinker().downcallHandle(
        lib.find("ml_add").orElseThrow(),
        FunctionDescriptor.of(ValueLayout.JAVA_INT,
                              ValueLayout.JAVA_INT, ValueLayout.JAVA_INT));
    System.out.println((int) add.invokeExact(2, 3));   // 5
}

// Node 24 — koffi (네이티브 빌드 없이 로드)
const koffi = require('koffi');
const lib = koffi.load('./libmathlib.so');
const ml_add = lib.func('int ml_add(int, int)');
console.log(ml_add(2, 3));         // 5

// 러스트 — extern "C" 선언만 하면 됩니다
#[link(name = "mathlib")]
extern "C" { fn ml_add(a: i32, b: i32) -> i32; }

fn main() { unsafe { println!("{}", ml_add(2, 3)); } }

새니타이저 — 가장 값싸고 강력한 도구

# ① 주소 새니타이저 — 메모리 오류 종합 검출 (2배 느림)
gcc -std=c17 -g -O1 -fsanitize=address,undefined \
    -fno-omit-frame-pointer app.c -o app
./app

# 잡아 주는 것:
#   heap-buffer-overflow    배열 밖 읽기/쓰기
#   stack-buffer-overflow   지역 배열 넘침
#   heap-use-after-free     free 뒤 접근
#   double-free             두 번 해제
#   memory leak             종료 시 안 푼 메모리 (LeakSanitizer 포함)

# ② UB 새니타이저 — 미정의 동작 검출
gcc -fsanitize=undefined -fno-sanitize-recover=all app.c -o app
#   부호 있는 정수 오버플로 · 널 역참조 · 정렬 위반 · 시프트 범위 초과

# ③ 옵션으로 더 엄격하게
ASAN_OPTIONS=detect_leaks=1:abort_on_error=1 ./app
UBSAN_OPTIONS=print_stacktrace=1 ./app

=================================================================
==31337==ERROR: AddressSanitizer: heap-buffer-overflow on address
0x602000000018 at pc 0x0001 bp 0x7ffd sp 0x7ffd
WRITE of size 4 at 0x602000000018 thread T0
    #0 0x1149 in main app.c:7          ← 여기서 넘어 썼습니다

0x602000000018 is located 0 bytes to the right of 8-byte region
allocated by thread T0 here:
    #0 0x7f4a in malloc
    #1 0x1122 in main app.c:5          ← 여기서 할당했습니다

gdb — 외워야 할 명령은 열 개뿐

# 코어 덤프 켜기 (평소엔 꺼져 있습니다)
ulimit -c unlimited
cat /proc/sys/kernel/core_pattern      # 어디에 떨어지는지 확인
./app                                  # 죽으면 core 파일 생성

gdb ./app core
(gdb) bt full                          # 스택 + 각 프레임의 지역 변수
(gdb) f 2                              # 내 코드가 있는 프레임으로
(gdb) p *node                          # 구조체 통째로 출력
(gdb) p node->next->value

# 죽은 이유가 바로 보이는 경우가 많습니다:
#   $1 = (Node *) 0x0        → 널 포인터였습니다
#   value = <optimized out>  → -O0 로 다시 빌드하세요

-O0 과 -O2 는 다른 프로그램입니다

# 배포 바이너리에서 심볼만 따로 떼어 보관하는 정석
gcc -O2 -g app.c -o app
objcopy --only-keep-debug app app.debug     # 심볼 파일 분리
objcopy --strip-debug app                   # 배포용은 가볍게
objcopy --add-gnu-debuglink=app.debug app   # 연결 정보만 남김

# 나중에 코어 덤프가 오면
gdb -s app.debug -e app core

CI 에 넣을 최소 구성

# .github/workflows/ci.yml — 이 정도면 충분합니다
name: ci
on: [push, pull_request]

jobs:
  test:
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - name: 빌드
        run: |
          cmake -B build -DCMAKE_BUILD_TYPE=Debug
          cmake --build build -j
      - name: 테스트
        run: ctest --test-dir build --output-on-failure

  sanitize:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: ASan + UBSan
        run: |
          cmake -B build -DCMAKE_C_FLAGS="-fsanitize=address,undefined -g -O1"
          cmake --build build -j
          ctest --test-dir build --output-on-failure

디렉터리 배치 — 사실상의 표준

myproj/
├── CMakeLists.txt
├── Makefile              # 간단한 경우 둘 중 하나만
├── README.md
├── .clang-format
├── .gitignore
├── include/
│   └── myproj/           # ★ 폴더를 한 겹 더 — #include "myproj/vec.h"
│       ├── vec.h         #   이름 충돌을 원천 차단합니다
│       └── str.h
├── src/
│   ├── main.c
│   ├── vec.c
│   ├── str.c
│   └── internal.h        # ★ 내부 전용 헤더는 src 안에
├── tests/
│   ├── test_vec.c
│   └── unity/            # 테스트 프레임워크
├── third_party/          # 외부 라이브러리 원본 (stb 등)
├── examples/
│   └── demo.c
└── build/                # ★ .gitignore 대상. 절대 커밋하지 않습니다

.clang-format · .gitignore

# .clang-format — 팀 규칙을 파일 하나로 고정
BasedOnStyle: LLVM
Language: Cpp
IndentWidth: 4
TabWidth: 4
UseTab: Never
ColumnLimit: 100
PointerAlignment: Right          # char *p  (C 관습)
AlignConsecutiveAssignments: Consecutive
AllowShortFunctionsOnASingleLine: Inline
BreakBeforeBraces: Attach
SortIncludes: CaseSensitive
IncludeBlocks: Regroup
SpaceAfterCStyleCast: true

# .gitignore
build/
*.o
*.d
*.a
*.so
*.dll
*.exe
compile_commands.json
core
core.*
.cache/
.vscode/
.idea/

# 편집기 자동완성이 되게 — 이 파일 하나면 clangd 가 다 알아냅니다
cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
ln -sf build/compile_commands.json .

# Makefile 프로젝트라면 bear 로 생성합니다
bear -- make

# 저장할 때마다 포맷 (git 훅)
echo 'clang-format -i $(git diff --cached --name-only | grep -E "\.[ch]$")' \
  > .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit

SQLite — 소스 한 장으로 DB 를 넣습니다

// sqlite3.c(약 25만 줄 한 파일) + sqlite3.h 를 받아 함께 컴파일하면 끝입니다
#include "sqlite3.h"
#include <stdio.h>

int main(void) {
    sqlite3 *db;
    if (sqlite3_open("app.db", &db) != SQLITE_OK) return 1;

    sqlite3_exec(db,
        "CREATE TABLE IF NOT EXISTS log(id INTEGER PRIMARY KEY, msg TEXT)",
        NULL, NULL, NULL);

    // ★ 항상 준비된 문장(prepared statement) — SQL 주입을 막습니다
    sqlite3_stmt *st;
    sqlite3_prepare_v2(db, "INSERT INTO log(msg) VALUES(?)", -1, &st, NULL);
    sqlite3_bind_text(st, 1, "첫 기록", -1, SQLITE_STATIC);
    sqlite3_step(st);
    sqlite3_finalize(st);

    sqlite3_prepare_v2(db, "SELECT id, msg FROM log", -1, &st, NULL);
    while (sqlite3_step(st) == SQLITE_ROW)
        printf("%d: %s\n", sqlite3_column_int(st, 0),
                           sqlite3_column_text(st, 1));
    sqlite3_finalize(st);
    sqlite3_close(db);
}
// gcc main.c sqlite3.c -o app -lpthread -ldl

libcurl + cJSON — API 를 부르고 파싱하기

#include <curl/curl.h>
#include <cjson/cJSON.h>
#include <stdlib.h>
#include <string.h>

typedef struct { char *p; size_t n; } Buf;

static size_t on_data(void *src, size_t sz, size_t nm, void *ud) {
    size_t total = sz * nm;
    Buf *b = ud;
    char *q = realloc(b->p, b->n + total + 1);
    if (!q) return 0;                       // 0 을 반환하면 전송이 중단됩니다
    b->p = q;
    memcpy(b->p + b->n, src, total);
    b->n += total;
    b->p[b->n] = '\0';
    return total;
}

int main(void) {
    curl_global_init(CURL_GLOBAL_DEFAULT);
    CURL *c = curl_easy_init();
    Buf buf = {0};

    curl_easy_setopt(c, CURLOPT_URL, "https://api.example.com/items");
    curl_easy_setopt(c, CURLOPT_WRITEFUNCTION, on_data);
    curl_easy_setopt(c, CURLOPT_WRITEDATA, &buf);
    curl_easy_setopt(c, CURLOPT_TIMEOUT, 10L);          // ★ 타임아웃 필수
    curl_easy_setopt(c, CURLOPT_FOLLOWLOCATION, 1L);

    if (curl_easy_perform(c) == CURLE_OK) {
        cJSON *root = cJSON_Parse(buf.p);
        cJSON *name = cJSON_GetObjectItemCaseSensitive(root, "name");
        if (cJSON_IsString(name)) printf("이름: %s\n", name->valuestring);
        cJSON_Delete(root);                             // ★ 해제는 내 책임
    }
    free(buf.p);
    curl_easy_cleanup(c);
    curl_global_cleanup();
}
// gcc main.c -o app -lcurl -lcjson

읽어 볼 만한 코드베이스

2026년의 C — 어디로 가고 있나

// raylib — "10줄로 창 띄우기". 배우기 가장 즐거운 C 라이브러리
#include "raylib.h"

int main(void) {
    InitWindow(800, 450, "안녕 raylib");
    SetTargetFPS(60);
    while (!WindowShouldClose()) {
        BeginDrawing();
            ClearBackground(RAYWHITE);
            DrawText("C 로 만든 창입니다", 190, 200, 20, DARKGRAY);
            DrawCircle(GetMouseX(), GetMouseY(), 20, MAROON);
        EndDrawing();
    }
    CloseWindow();
}
// gcc main.c -o game -lraylib -lm -lpthread -ldl

문제 — 손으로 정리하면 반드시 빠뜨립니다

void process(const char* path) {
    FILE* f = std::fopen(path, "r");
    std::mutex& m = get_mutex();
    m.lock();
    int* buf = new int[1024];

    if (!validate()) return;          // ❌ 셋 다 안 풀림
    if (parse(f) < 0) { m.unlock(); return; }   // ❌ 두 개 빠짐
    risky();                          // ❌ 예외가 나면 전부 샘

    delete[] buf;
    m.unlock();
    std::fclose(f);
}
//  경로가 늘어날수록 정리 코드가 곱하기로 늘어납니다.
//  예외까지 고려하면 사람이 지킬 수 없습니다.

해법 — 자원을 객체에 묶습니다

void process(const std::filesystem::path& path) {
    std::ifstream f(path);                    // 소멸자가 닫음
    std::lock_guard lk(get_mutex());          // 소멸자가 풂
    std::vector<int> buf(1024);               // 소멸자가 해제

    if (!validate()) return;      // ✅ 셋 다 자동 정리
    if (parse(f) < 0) return;     // ✅
    risky();                      // ✅ 예외가 나도 정리됨
}                                 // ✅ 정상 종료도 정리됨
//  ★ 정리 코드가 한 줄도 없습니다.

// 표준 라이브러리는 이미 전부 RAII 입니다
std::vector · std::string · std::unique_ptr · std::shared_ptr
std::lock_guard · std::unique_lock · std::scoped_lock
std::ifstream · std::ofstream · std::jthread(C++20)
std::filesystem 의 임시 경로 관리

가장 좋은 클래스는 아무것도 안 쓴 클래스

// ★ 0의 법칙 — 소멸자·복사·이동을 하나도 정의하지 않는 것이 최선입니다
class Report {
    std::string              title_;
    std::vector<double>      data_;
    std::unique_ptr<Cache>   cache_;
    // 여섯 개 특수 멤버가 전부 올바르게 자동 생성됩니다 ★
};

// 5의 법칙 — 하나라도 직접 쓰면 나머지도 검토해야 합니다
//   소멸자 / 복사 생성 / 복사 대입 / 이동 생성 / 이동 대입
// 특히 ⚠ 소멸자를 정의하면 '이동'이 자동 생성되지 않아
//        조용히 복사로 후퇴합니다 (성능이 몇 배 나빠짐)

class Buffer {
public:
    ~Buffer() { log("해제"); }              // 소멸자를 썼더니
    Buffer(Buffer&&) = default;             // ★ 이것들을 명시해야 합니다
    Buffer& operator=(Buffer&&) = default;
    Buffer(const Buffer&) = default;
    Buffer& operator=(const Buffer&) = default;
private:
    std::vector<std::byte> d_;
};

// 검증 — 컴파일 시점에 못 박아 두세요
static_assert(std::is_nothrow_move_constructible_v<Buffer>);

예외 안전성 세 등급

// 강한 보장의 관용구 — copy and swap
class Config {
    std::map<std::string, std::string> kv_;
public:
    void merge(const Config& other) {
        Config tmp(*this);              // ① 사본에서 작업
        for (const auto& [k, v] : other.kv_)
            tmp.kv_[k] = v;             //    여기서 던져도 원본은 무사
        swap(tmp);                      // ② 성공했을 때만 교체 (noexcept)
    }
    void swap(Config& o) noexcept { kv_.swap(o.kv_); }
};

// ★ 반드시 noexcept 여야 하는 것들
//   소멸자 (기본으로 noexcept — 던지면 terminate)
//   이동 생성자·이동 대입   ← vector 재할당 성능에 직결
//   swap
//   해제 함수

언제 어떤 순서로 불리나

// ① 지역 객체 — 선언의 역순 ★
void f() {
    A a;    // 세 번째로 소멸
    B b;    // 두 번째
    C c;    // 첫 번째
}           // ~C → ~B → ~A

// ② 멤버 — 선언 순서의 역순 (초기화는 선언 순서)
class X {
    A a_;   // 두 번째 소멸
    B b_;   // 첫 번째 소멸
};

// ③ 임시 객체 — 그 식(full-expression)이 끝날 때
f(std::string("임시").c_str());     // f 가 끝난 뒤 소멸 — 안전
const char* p = std::string("임시").c_str();
use(p);                             // ❌ 이미 소멸 — 댕글링

// ④ 임시의 수명 연장 — const 참조에 바인딩하면 늘어납니다
const std::string& s = make_string();   // ✅ s 의 수명까지 연장
std::string_view sv = make_string();    // ❌ view 는 연장되지 않습니다 ★

// ⑤ 정적 객체 — main 이 끝난 뒤, 생성의 역순
//    ⚠ 번역 단위 간의 초기화 순서는 정해져 있지 않습니다 (정적 초기화 순서 문제)
//    → 함수 안 static 으로 피하세요 (첫 호출 때 생성 · 스레드 안전)
Logger& logger() { static Logger l; return l; }

RAII 가 깨지는 자리

// ① 소멸자가 불리지 않는 경우들
std::exit(1);          // 지역 객체의 소멸자가 불리지 않습니다
std::abort();          // 마찬가지
std::terminate();
longjmp();             // C 의 점프 — 소멸자를 건너뜁니다 ★
//   → 종료 처리가 필요하면 std::atexit 이나 명시적 정리를 쓰세요

// ② detach 된 스레드
std::thread t(work);
t.detach();            // main 이 끝나면 스레드 객체가 정리 안 된 채 종료
//   → std::jthread (C++20) 는 소멸자에서 join 합니다 ★

// ③ 순환 참조 (shared_ptr)
struct Node { std::shared_ptr<Node> next; };
//   서로를 가리키면 카운트가 0이 되지 않아 소멸자가 안 불립니다 (m02)

// ④ 예외가 스레드 밖으로 나가면
std::thread t([]{ throw std::runtime_error("x"); });   // terminate
//   → 스레드 함수 전체를 try 로 감싸세요

// ⑤ 컨테이너에 원시 포인터를 담은 경우
std::vector<Widget*> v;    // 벡터가 비워져도 Widget 은 안 지워집니다
std::vector<std::unique_ptr<Widget>> v2;   // ✅

unique_ptr — 기본값

#include <memory>

auto p = std::make_unique<Widget>(arg1, arg2);   // ★ new 대신 이것
p->draw();
(*p).draw();
p.get();          // 원본 포인터 (C API 에 넘길 때)
p.reset();        // 지금 해제
p = nullptr;      // 같은 뜻

// 복사 불가 · 이동만 가능 — "소유자는 하나"를 타입이 강제합니다
auto q = p;              // ❌ 컴파일 에러
auto q = std::move(p);   // ✅ 소유권 이전 (p 는 이제 nullptr)

// 함수 인터페이스로 의도를 표현
std::unique_ptr<Widget> create();          // "받는 쪽이 소유합니다"
void consume(std::unique_ptr<Widget> w);   // "넘기면 내 것이 됩니다"
void use(const Widget& w);                 // "잠깐 빌려 봅니다" ★
void use(Widget* w);                       // "빌려 보되 없을 수도"

// 배열도 됩니다 (대개 vector 가 낫습니다)
auto arr = std::make_unique<double[]>(1000);
arr[0] = 1.0;

// 비용 — 원시 포인터와 완전히 같습니다 (크기 8바이트, 오버헤드 0) ★

shared_ptr — 정말 필요할 때만

auto s = std::make_shared<Widget>(args);   // 참조 카운트 방식
auto s2 = s;                                // 카운트 +1
s.use_count();                              // 현재 소유자 수
//  마지막 shared_ptr 이 사라질 때 해제됩니다

// weak_ptr — 보기만 하고 수명에 관여하지 않습니다
std::weak_ptr<Widget> w = s;
if (auto locked = w.lock()) {               // 살아 있으면 shared_ptr 획득
    locked->draw();
}

// ⚠ 순환 참조 — 서로 shared_ptr 이면 영원히 해제되지 않습니다 ★
struct Node {
    std::shared_ptr<Node> child;
    std::weak_ptr<Node>   parent;    // ★ 부모는 weak 로 끊습니다
};

// 비용 — 원시 포인터의 두 배 크기 + 원자적 카운트 연산
sizeof(std::unique_ptr<int>);   // 8
sizeof(std::shared_ptr<int>);   // 16 (포인터 + 제어 블록 포인터)
//   복사할 때마다 원자 연산이 일어나 멀티스레드에서 경합이 생깁니다

함수 시그니처가 곧 계약입니다

// ❌ 흔한 실수 — 읽기만 하는데 shared_ptr 을 값으로 받기
void draw(std::shared_ptr<Widget> w);    // 호출마다 원자 카운트 증감
// ✅ 소유에 관심이 없으면 참조나 원시 포인터로
void draw(const Widget& w);              // ★ 이것이 기본
//   호출 쪽: draw(*ptr);

팀 규칙으로 굳히기

// ① new / delete 를 코드에서 금지 (린터로 강제)
//    .clang-tidy
//      Checks: 'modernize-make-unique,
//               cppcoreguidelines-owning-memory,
//               cppcoreguidelines-no-malloc,
//               bugprone-use-after-move'

// ② 원시 포인터는 '빌려 보는 것'만 — 소유를 표현하지 않습니다
//    소유가 필요하면 unique_ptr, 관찰만이면 T* 또는 T&

// ③ make_unique / make_shared 를 쓰세요
auto p = std::unique_ptr<Widget>(new Widget(a, b));   // ❌ 장황
auto p = std::make_unique<Widget>(a, b);              // ✅
//   ★ f(std::unique_ptr<A>(new A), g()) 는 예외 시 누수 가능성이 있었습니다
//     (C++17 에서 완화됐지만 make_ 를 쓰는 편이 안전하고 짧습니다)

// ④ make_shared 의 장단
//    ✅ 객체와 제어 블록을 한 번에 할당 → 할당 1회 · 캐시 유리
//    ⚠ weak_ptr 이 남아 있으면 객체 메모리도 함께 유지됩니다
//      (큰 객체 + 오래 사는 weak_ptr 조합에서는 shared_ptr(new T) 가 나을 수 있음)

shared_ptr 내부

shared_ptr 은 두 개의 포인터입니다
  ① 객체 포인터
  ② 제어 블록 포인터 → { 강한 카운트, 약한 카운트, 삭제자, 할당자 }

make_shared<T>(args)
  객체와 제어 블록을 한 번에 할당 (할당 1회) ★
  → 캐시 지역성이 좋고 빠릅니다
  ⚠ 대신 weak_ptr 이 하나라도 살아 있으면
    객체 메모리 전체가 해제되지 않습니다 (제어 블록과 붙어 있으므로)

shared_ptr<T>(new T(args))
  할당 2회 (객체 + 제어 블록)
  → weak_ptr 이 남아도 객체 메모리는 즉시 해제됩니다

카운트 연산 비용
  · 복사·소멸마다 원자적 증감 (lock 접두 명령)
  · 여러 스레드가 같은 shared_ptr 을 복사하면 캐시 라인 경합 ★
  · 그래서 핫 루프에서 shared_ptr 을 값으로 넘기면 눈에 띄게 느려집니다
    → const shared_ptr& 또는 원시 참조로 넘기세요

측정하고 확인하기

// 할당 횟수를 세어 보기
static std::atomic<int> g_allocs{0};
void* operator new(std::size_t n) { ++g_allocs; return std::malloc(n); }
void  operator delete(void* p) noexcept { std::free(p); }

int main() {
    { auto p = std::make_shared<Widget>(); }          // 1회
    { auto p = std::shared_ptr<Widget>(new Widget); } // 2회
    std::printf("%d\n", g_allocs.load());
}

// 값 전달 vs 참조 전달의 차이를 재 보기
void by_value(std::shared_ptr<Widget> p)        { use(*p); }
void by_ref(const std::shared_ptr<Widget>& p)   { use(*p); }
void by_raw(const Widget& w)                    { use(w); }

// 1000만 번 호출 시 (환경마다 다릅니다 — 직접 재세요)
//   by_value : 원자 연산 2000만 번 → 눈에 띄게 느림
//   by_ref   : 거의 0
//   by_raw   : 0  ★ 인터페이스로 가장 좋습니다

// 원자 연산 비용 확인
// perf stat -e cache-misses,LLC-store-misses ./bench

복사와 이동의 차이

std::vector<int> a(1'000'000);

// 복사 — 100만 개를 새 메모리에 전부 옮겨 적습니다 (느림)
std::vector<int> b = a;              // a 는 그대로 살아 있습니다

// 이동 — 내부 포인터만 넘겨받습니다 (거의 공짜) ★
std::vector<int> c = std::move(a);   // a 는 '비어 있지만 유효한' 상태가 됩니다
a.size();                            // 0 (읽어도 UB 는 아닙니다)
a.push_back(1);                      // 다시 써도 됩니다

// vector 내부를 그림으로 보면
//   복사: [ptr|size|cap] → 새 버퍼를 잡고 100만 개 memcpy
//   이동: [ptr|size|cap] 세 값만 옮기고 원본은 nullptr 로  ★ 8바이트 3개

// std::move 는 '옮기는 함수'가 아닙니다 ★
//   그냥 "이건 훔쳐 가도 된다"고 표시하는 캐스트일 뿐입니다.
//   실제 이동은 이동 생성자·이동 대입이 합니다.

언제 자동으로 이동되나

// ① 임시 객체(rvalue)를 대입할 때 — 자동으로 이동
std::vector<int> v = make_vector();     // 이동 (또는 RVO 로 아예 생략)
v = make_vector();                       // 이동 대입

// ② 함수에서 지역 변수를 반환할 때 — 자동
std::vector<int> f() {
    std::vector<int> local(1000);
    return local;                        // ✅ 이동 (사실 대개 RVO 로 복사·이동 둘 다 생략)
    // return std::move(local);          // ❌ 오히려 RVO 를 막습니다
}

// ③ 컨테이너에 임시를 넣을 때
v.push_back(make_widget());              // 이동
v.push_back(std::move(w));               // 명시적 이동
v.emplace_back(args...);                 // 아예 그 자리에서 생성 ★

// ④ 명시적으로 넘길 때
process(std::move(big_data));            // "더 안 쓸 거니까 가져가"

// ⚠ const 객체는 이동되지 않습니다 (복사로 후퇴)
const std::vector<int> cv(1000);
auto x = std::move(cv);                  // 조용히 '복사'됩니다 ★
//   → 이동시킬 값에 const 를 붙이지 마세요

'보관할 것'은 값으로 받고 move

class Logger {
    std::string name_;
public:
    // ✅ 관용구 — 복사가 딱 한 번만 일어납니다
    explicit Logger(std::string name) : name_(std::move(name)) {}
};

Logger a("파일");                     // 임시 → 이동 (복사 0)
std::string n = "파일";
Logger b(n);                          // 복사 1회 (불가피)
Logger c(std::move(n));               // 이동 (복사 0)

// ❌ 예전 방식 — const& 로만 받으면 임시여도 복사가 일어납니다
explicit Logger(const std::string& name) : name_(name) {}   // 항상 복사 1회

// ⚠ 값으로 받고 move 하지 않으면 복사가 두 번 됩니다
explicit Logger(std::string name) : name_(name) {}          // ❌ move 누락

// 컨테이너에 넣을 때
v.push_back(w);              // 복사
v.push_back(std::move(w));   // 이동
v.emplace_back(a, b);        // ★ 임시 객체 없이 그 자리에서 생성

// map 에 넣기
m.emplace(key, std::move(value));
m.try_emplace(key, args...);          // ★ 이미 있으면 value 를 만들지도 않음

복사가 남아 있는 곳 찾기

// ① 진단용 구조체를 프로젝트에 하나 두세요 (기초 탭 x07 과 같은 것)
struct Trace {
    Trace() { std::puts("생성"); }
    Trace(const Trace&) { std::puts("★복사★"); }
    Trace(Trace&&) noexcept { std::puts("이동"); }
    ~Trace() { std::puts("소멸"); }
};

// ② 컴파일러 경고로 잡기
//    -Wreturn-std-move  -Wpessimizing-move  -Wredundant-move
g++ -Wall -Wextra -Wpessimizing-move -Wredundant-move
//   return std::move(local);  → warning: moving a local object prevents copy elision

// ③ clang-tidy 규칙
//    performance-unnecessary-value-param
//    performance-move-const-arg
//    performance-for-range-copy        ← for (auto x : v) 잡아 줍니다 ★
//    modernize-pass-by-value

// ④ 프로파일러로 확인
//    perf record -g ./app && perf report
//    memcpy · operator new 가 상위에 보이면 복사가 남아 있습니다

lvalue · rvalue · xvalue

C++ 의 모든 식은 값 카테고리를 가집니다

            expression
            /        \
        glvalue      rvalue
        /     \      /     \
    lvalue    xvalue      prvalue

  lvalue  : 이름이 있고 주소를 얻을 수 있음      int x;  x
  prvalue : 순수한 임시값                        42,  f()
  xvalue  : 곧 사라질 것 (eXpiring)              std::move(x)
  rvalue  : prvalue + xvalue → '훔쳐 가도 되는 것'

  T&   (lvalue 참조)  : lvalue 에만 바인딩
  const T&            : 둘 다 바인딩 (그래서 예전엔 이것만 썼습니다)
  T&&  (rvalue 참조)  : rvalue 에만 바인딩 → 이동의 근거 ★

  ★ 핵심 혼동: 'T&& 인 변수 자체는 lvalue 입니다'
    void f(Widget&& w) { g(w); }              // 복사됩니다!
    void f(Widget&& w) { g(std::move(w)); }   // ✅ 이동
    (이름이 있으면 lvalue — 예외 없는 규칙입니다)

완벽 전달 — 받은 그대로 넘기기

// 템플릿의 T&& 는 rvalue 참조가 아니라 '전달 참조' 입니다 ★
template<class T>
void wrapper(T&& arg) {                 // T 가 추론될 때만 전달 참조
    inner(std::forward<T>(arg));        // lvalue 면 lvalue 로, rvalue 면 rvalue 로
}
//   forward 는 '조건부 move' 입니다 — 원래 카테고리를 복원합니다

// 참조 접힘 규칙 (왜 이게 되는지)
//   T = Widget&   → Widget& &&  → Widget&    (lvalue 를 넘긴 경우)
//   T = Widget    → Widget&&               (rvalue 를 넘긴 경우)

// 실제 쓰임 — make_unique 의 구현이 이것입니다
template<class T, class... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// emplace_back 도 같은 원리 — 인자를 그대로 생성자에 전달합니다
v.emplace_back(std::string("x"), 42);   // 임시 없이 그 자리에서 생성

// ⚠ 전달 참조는 오버로드를 다 잡아먹습니다
template<class T> void f(T&&);          // 거의 모든 타입에 매칭
void f(int);                            // 정확히 int 일 때만 이깁니다
short s = 1;  f(s);                     //   short·long·char 는 템플릿으로 갑니다
//   → 컨셉으로 제약을 걸어야 합니다 (m09)
template<class T> requires (!std::integral<std::remove_cvref_t<T>>)
void f(T&&);                            // 정수는 전부 f(int) 로
//   (T&& 에 lvalue 가 오면 T = int& 라 remove_cvref_t 로 벗겨서 검사)

const 정확성

class Report {
    std::vector<double> data_;
    mutable std::optional<double> cache_;   // ★ const 함수에서도 바꿀 수 있음
public:
    // 읽기만 하는 함수에는 반드시 const
    std::size_t size() const noexcept { return data_.size(); }

    double mean() const {                   // const 함수인데 캐시는 갱신
        if (!cache_) cache_ = compute();
        return *cache_;
    }

    // const 버전과 비const 버전을 함께 제공하는 관용구
    double&       at(std::size_t i)       { return data_[i]; }
    const double& at(std::size_t i) const { return data_[i]; }
};

const Report r = load();
r.size();      // ✅ const 함수만 부를 수 있습니다
r.at(0) = 1;   // ❌ 컴파일 에러 — 여기서 실수를 막습니다

// 왜 중요한가
//   ① 의도가 코드에 드러납니다 (주석이 아니라 컴파일러가 보증)
//   ② const 객체는 여러 스레드가 동시에 읽어도 안전합니다 ★
//   ③ 컴파일러가 더 나은 코드를 만듭니다

constexpr — 컴파일 시점 계산

constexpr int square(int x) { return x * x; }

constexpr int a = square(5);      // 컴파일 시점에 25 로 확정 ★
int n = read_input();
int b = square(n);                // 런타임에 계산 (같은 함수로 둘 다 됩니다)

// 배열 크기 · 템플릿 인자로 쓸 수 있습니다
constexpr std::size_t kBufSize = 1024 * 4;
std::array<std::byte, kBufSize> buf;

// C++20 — 반드시 컴파일 시점에만 실행되게
consteval int must_be_compile_time(int x) { return x * 2; }

// 컴파일 시점에 실행 중인지 분기
constexpr int f(int x) {
    if (std::is_constant_evaluated()) return slow_but_exact(x);
    return fast_approx(x);
}

// 표준 라이브러리도 상당수 constexpr 입니다 (C++20+)
constexpr std::array<int, 5> sorted = []{
    std::array<int, 5> a{5,3,1,4,2};
    std::sort(a.begin(), a.end());    // ★ 컴파일 시점에 정렬됩니다
    return a;
}();

// 매크로를 대체합니다
#define MAX 100                       // ❌ 타입도 스코프도 없음
constexpr int kMax = 100;             // ✅

어디에 붙이나

// ❌ 반환값에 const 를 붙이면 이동이 막힙니다
const std::string get();      // s = get(); 처럼 대입하면 이동 대신 복사됩니다
std::string get();            // ✅

// ⚠ const 는 스레드 안전을 '의미'합니다 (C++11 이후 표준 관례)
//   const 함수는 여러 스레드가 동시에 불러도 안전해야 합니다.
//   mutable 캐시를 두면 그 약속이 깨집니다 → mutex 로 보호하세요
mutable std::mutex m_;
mutable std::optional<double> cache_;

const 를 벗기는 것에 대하여

// const_cast — 거의 항상 설계가 잘못됐다는 신호입니다
void f(const Widget& w) {
    const_cast<Widget&>(w).modify();   // ❌ 원본이 진짜 const 면 UB ★
}

// 유일하게 정당한 경우 — const 가 아닌 객체를 const 참조로 받았을 때
//   (그리고 그 사실을 확실히 알 때). 그런 설계 자체를 피하세요.

// 옛 C API 가 const 를 안 쓸 때는 어쩔 수 없습니다
void c_api(char* s);                   // 실제로는 수정하지 않는데 const 가 없음
std::string t = s;
c_api(t.data());                       // ✅ 복사본을 넘기는 편이 안전

// 중복 제거의 정석 (const 버전에서 비const 버전 부르기)
class C {
    const T& get() const { /* 복잡한 로직 */ }
    T& get() {
        return const_cast<T&>(std::as_const(*this).get());   // 관용구
    }
};
//   ★ 반대 방향(비const 에서 const 로 위임)은 안전하지 않습니다

생각보다 도움이 안 됩니다

// 흔한 오해 — "const 를 붙이면 빨라진다"
void f(const int& x, int& y) {
    int a = x;
    y = 1;
    int b = x;        // ★ 컴파일러는 x 를 다시 읽어야 합니다
}
//   왜? x 와 y 가 같은 객체일 수 있고(aliasing),
//   const 참조는 '내가 안 바꾼다'는 뜻이지 '아무도 안 바꾼다'가 아닙니다.

// 진짜로 최적화에 도움이 되는 것들
//   ① constexpr — 아예 계산이 사라집니다 ★
//   ② 지역 const 변수 — 컴파일러가 값을 추적할 수 있습니다
//   ③ const 전역·정적 — 읽기 전용 섹션(.rodata)에 배치돼 공유됩니다
//   ④ __restrict — "겹치지 않는다"를 알려 주면 벡터화가 됩니다(⚡ e06)

// 확인 — godbolt 에서 const 있는 버전과 없는 버전의 어셈블리를 비교해 보세요
//   대부분의 경우 완전히 동일한 코드가 나옵니다.

// ★ 그래도 const 를 쓰는 이유는 '성능'이 아니라
//   ① 실수 방지 ② 의도 표현 ③ 스레드 안전 판단 근거 입니다.

constexpr 의 한계와 대안

// 컴파일 시점 계산의 비용 — 빌드 시간입니다
//   큰 테이블이나 복잡한 계산을 constexpr 로 하면 컴파일이 느려집니다
//   측정: clang++ -ftime-trace 로 어느 constexpr 이 오래 걸리는지 확인

// 컴파일러 제한에 걸릴 수 있습니다
//   -fconstexpr-ops-limit=  (GCC)
//   -fconstexpr-steps=      (Clang)
//   error: constexpr evaluation hit maximum step limit

// 대안 — 빌드 단계에서 코드를 생성
//   ① 스크립트로 .h 파일 생성 (CMake add_custom_command)
//   ② 실행 시 한 번만 초기화 (함수 안 static — 스레드 안전 보장)
const auto& lut() {
    static const auto t = make_lut();     // 첫 호출 때 한 번
    return t;
}

// C++20 constinit — '컴파일 시점 초기화'를 강제 (정적 초기화 순서 문제 회피)
constinit static Logger g_logger{};       // 동적 초기화면 컴파일 에러 ★

// 정리
//   작은 상수·간단한 계산 → constexpr
//   큰 테이블            → 생성 스크립트나 함수 안 static
//   전역 객체            → constinit 또는 함수 안 static

선택 순서도

키로 찾아야 하나?
  ├─ 예 → 순서대로 순회해야 하나?
  │        ├─ 예 → std::map · std::set          (트리, O(log n))
  │        └─ 아니오 → std::unordered_map · set  (해시, O(1)) ★
  └─ 아니오 → 크기가 컴파일 시점에 정해지나?
             ├─ 예 → std::array<T, N>            (스택, 할당 없음)
             └─ 아니오 → 양쪽 끝에서 넣고 빼나?
                        ├─ 예 → std::deque
                        └─ 아니오 → std::vector  ★ 기본값

  그 외
    · 항상 정렬 상태 유지 + 중복 허용 → std::multiset · sorted vector
    · 우선순위 큐                     → std::priority_queue
    · 고정 크기 비트 집합              → std::bitset
    · 문자열                          → std::string · std::string_view

복잡도 비교

* 상각(amortized) — 가끔 재할당이 일어납니다

재할당과 반복자 무효화

// ① 크기를 알면 반드시 reserve
std::vector<Row> rows;
rows.reserve(expected);            // 재할당 0회 ★

// ② 참조·포인터를 보관해야 하면 vector 를 쓰지 마세요
std::vector<Widget> v;
Widget* p = &v[0];
v.push_back(w);                    // 재할당되면 p 는 죽습니다 ★
//   → deque · list · unordered_map(참조 안정) 또는 인덱스를 보관

// ③ 무효화 규칙 요약
//   vector      : 재할당 시 전부 · erase 이후 뒤쪽
//   deque       : 중간 수정 시 전부 · 양끝 삽입은 반복자만(참조는 유지)
//   list · map  : 지운 그것만
//   u_map       : 리해시 시 반복자만 (참조·포인터는 유지) ★

// ④ 순회 중 수정 (기초 탭 x04 와 같은 규칙)
for (auto it = v.begin(); it != v.end(); ) {
    if (drop(*it)) it = v.erase(it);
    else           ++it;
}
std::erase_if(v, drop);            // ✅ C++20 — 이게 더 빠르고 안전합니다

메모리를 재사용하는 패턴

// ❌ 루프마다 새 벡터 — 할당이 반복됩니다
for (const auto& chunk : chunks) {
    std::vector<double> tmp;
    process(chunk, tmp);
}

// ✅ 밖에 두고 clear 로 재사용 — 용량이 유지됩니다 ★
std::vector<double> tmp;
tmp.reserve(max_size);
for (const auto& chunk : chunks) {
    tmp.clear();                   // size 만 0, 메모리는 유지
    process(chunk, tmp);
}

// 다형적 메모리 자원 (C++17) — 아레나에서 할당
#include <memory_resource>
std::array<std::byte, 64 * 1024> buf;
std::pmr::monotonic_buffer_resource pool{buf.data(), buf.size()};
std::pmr::vector<int> v{&pool};    // ★ 힙 할당 없이 스택 버퍼 사용
v.reserve(1000);                    // pool 에서 가져옵니다
//   요청 처리처럼 '한 번에 만들고 한 번에 버리는' 작업에 적합합니다
//   해제는 pool 이 통째로 — 개별 free 가 없어 매우 빠릅니다

노드 기반의 진짜 비용

std::map<int, int> 원소 하나당 실제 메모리 (libstdc++ 기준)

  키 4 + 값 4 = 8바이트가 실제 데이터
  + 좌·우·부모 포인터 24바이트
  + 색상(레드블랙) + 패딩 8바이트
  + 할당자 오버헤드 ~16바이트
  = 원소당 약 56바이트 ★ 데이터의 7배

std::unordered_map<int,int>
  노드 (키+값+next 포인터) + 버킷 배열
  = 원소당 약 40~50바이트

std::vector<std::pair<int,int>>
  = 원소당 8바이트 (+ 여유 용량) ★

→ 100만 개면 56MB vs 8MB.
  게다가 map 은 원소가 메모리에 흩어져 있어
  순회할 때마다 캐시 미스가 납니다.

★ 그래서 실무 결론:
  '정렬된 vector + binary_search' 가
  map 보다 빠른 경우가 매우 흔합니다 (읽기 위주라면 거의 항상).

직접 재 보고 판단하기

// 같은 작업을 세 가지로 구현해 비교
#include <chrono>
template<class F> auto bench(F f) {
    auto t = std::chrono::steady_clock::now();
    f();
    return std::chrono::duration<double, std::milli>(
        std::chrono::steady_clock::now() - t).count();
}

// ① map
std::map<int,int> m;
// ② unordered_map
std::unordered_map<int,int> um;  um.reserve(N);
// ③ 정렬된 vector
std::vector<std::pair<int,int>> v;  v.reserve(N);
std::ranges::sort(v, {}, &std::pair<int,int>::first);
auto it = std::ranges::lower_bound(v, key, {}, &std::pair<int,int>::first);

// 전형적인 결과의 경향 (직접 재세요)
//   삽입이 잦고 순서가 필요 없다        → unordered_map
//   만들어 두고 읽기만 · 순회가 잦다     → 정렬된 vector ★
//   범위 조회가 필요하다               → 정렬된 vector 또는 map
//   원소가 수십 개                     → 무엇을 써도 차이 없음 (vector 로)

자주 쓰는 것들

#include <algorithm>
#include <numeric>
#include <ranges>
namespace rg = std::ranges;

// C++20 ranges — begin/end 를 안 적어도 됩니다 ★
rg::sort(v);
rg::sort(people, {}, &Person::age);        // 프로젝션으로 정렬 기준 지정
rg::stable_sort(v);                        // 같은 값의 순서 유지
rg::find(v, 42);
rg::find_if(v, [](int x){ return x > 0; });
rg::count(v, 42);
rg::any_of(v, pred);  rg::all_of(v, pred);  rg::none_of(v, pred);
rg::min_element(v);   rg::max_element(v);
rg::reverse(v);       rg::rotate(v, v.begin()+3);
rg::unique(v);                             // 인접 중복 제거 (정렬 후)
rg::binary_search(v, 42);                  // 정렬돼 있을 때
rg::lower_bound(v, 42);

// 수치
std::accumulate(v.begin(), v.end(), 0.0);  // 합 (초기값 타입 주의!) ★
std::reduce(v.begin(), v.end());           // 병렬 가능 버전
std::transform_reduce(a.begin(), a.end(), b.begin(), 0.0,
                      std::plus{}, std::multiplies{});   // 내적
std::partial_sum(...);  std::adjacent_difference(...);

// ⚠ accumulate(v.begin(), v.end(), 0) 에 double 벡터를 넣으면
//   0 이 int 라 결과가 int 로 잘립니다. 반드시 0.0 을 쓰세요 ★

views — 지연 평가 파이프라인

namespace vw = std::views;

// 파이썬의 컴프리헨션·제너레이터에 해당합니다
auto result = v
    | vw::filter([](int x){ return x % 2 == 0; })
    | vw::transform([](int x){ return x * x; })
    | vw::take(5);

for (int x : result) ...        // ★ 여기서야 실제로 계산됩니다 (지연 평가)

// 자주 쓰는 view
vw::filter · vw::transform · vw::take · vw::drop
vw::take_while · vw::drop_while
vw::reverse · vw::join · vw::split
vw::iota(0, 10)                  // 0..9 (파이썬 range)
vw::zip(a, b)                    // C++23 ★
vw::enumerate(v)                 // C++23 — 파이썬 enumerate
vw::chunk(v, 3) · vw::slide(v, 3)  // C++23

// 결과를 컨테이너로 (C++23)
auto vec = result | rg::to<std::vector>();
// C++20 이라면 — filter 뒤 take 는 begin/end 타입이 달라 views::common 으로 맞춥니다
auto c = result | vw::common;
std::vector<int> vec(c.begin(), c.end());

ranges 의 현실적인 한계

// ⚠ ① 컴파일 에러가 끔찍합니다
//    제약을 어기면 수백 줄짜리 템플릿 에러가 나옵니다.
//    → 컨셉(m09)이 도입되며 나아졌지만 여전히 어렵습니다.

// ⚠ ② 컴파일 시간이 늘어납니다
//    파이프라인이 길수록 템플릿 인스턴스화가 늘어납니다.

// ⚠ ③ 디버거로 들여다보기 어렵습니다
//    view 안에서 중단점을 걸어도 타입 이름이 수십 줄입니다.

// ⚠ ④ 성능이 항상 좋지는 않습니다
//    대부분 최적화로 사라지지만, 복잡한 파이프라인은
//    손으로 쓴 루프보다 느릴 수 있습니다 — 재 보세요.

// ⚠ ⑤ 수명 함정 — view 는 원본을 참조합니다 ★
auto bad() {
    std::vector<int> v{1,2,3};
    return v | vw::filter(pred);      // ❌ v 가 사라지면 댕글링
}
//   → 결과를 vector 로 실체화해서 반환하세요

// ✅ 그래도 쓰는 이유 — '무엇을 하는지'가 코드에 드러납니다
//    이름 있는 알고리즘 > 손으로 쓴 루프 (버그도 여기서 덜 납니다)

팀에서의 도입 기준

• 알고리즘(rg::sort·rg::find_if)은 적극 쓰세요 — 학습 비용이 거의 없고 이득이 명확합니다
• views 파이프라인은 2~3단계까지 — 그 이상은 함수로 나누는 편이 읽힙니다
• 핫 루프에는 손으로 — 측정해서 차이가 나면 명시적 루프로
• public 인터페이스에 view 를 노출하지 마세요 — 타입이 복잡하고 수명 문제가 생깁니다. std::span 이나 std::generator(C++23)를 쓰세요

// 인터페이스는 단순하게
std::vector<Row> filter_rows(std::span<const Row> in, const Query& q);
//   내부 구현에서는 ranges 를 마음껏 쓰되, 밖으로는 구체 타입으로

반복자 카테고리

알고리즘이 어떤 컨테이너에서 되는지를 결정합니다

  input      : 한 번만 앞으로 (istream)
  forward    : 여러 번 앞으로 (forward_list)
  bidirectional : 앞뒤로 (list, map)
  random_access : 점프 가능 (vector, deque, array) ★
  contiguous : 메모리가 연속 (vector, array, span) — C++20

  · std::sort 는 random_access 가 필요합니다
    → list 에는 못 씁니다. list.sort() 멤버 함수를 쓰세요
  · std::span 은 contiguous 를 요구합니다
    → deque 는 못 넘깁니다 (블록으로 나뉘어 있으므로)

C++20 부터는 컨셉으로 표현됩니다
  std::random_access_iterator<It>
  std::ranges::contiguous_range<R>
  → 제약을 어기면 '무엇이 부족한지' 한 줄로 알려 줍니다 (m09)

병렬 알고리즘

#include <execution>

std::sort(std::execution::par, v.begin(), v.end());
std::transform(std::execution::par_unseq,
               a.begin(), a.end(), out.begin(), f);
double s = std::reduce(std::execution::par, v.begin(), v.end());

// 실행 정책
//   seq       순차 (기본)
//   par       여러 스레드
//   par_unseq 여러 스레드 + 벡터화 (SIMD)
//   unseq     벡터화만 (C++20)

// ⚠ 주의점
//   · GCC 는 TBB 링크가 필요합니다: target_link_libraries(app PRIVATE tbb)
//   · f 는 스레드 안전해야 하고 예외를 던지면 terminate 입니다
//   · 원소가 적으면 스레드 생성 비용이 더 큽니다 (수만 개 이상부터)
//   · reduce 는 순서를 보장하지 않아 float 결과가 미세하게 달라질 수 있습니다 ★
//     (결정적 결과가 필요하면 accumulate 를 쓰세요)

// 파이썬 확장에서 쓸 때는 GIL 을 놓고 부르세요 (🐍 y07)
{
    py::gil_scoped_release rel;
    std::for_each(std::execution::par, ...);
}

캡처 규칙

int n = 10;
std::string s = "안녕";

[]        (int x){ return x * 2; }        // 아무것도 안 가져옴
[n]       (int x){ return x * n; }        // n 을 '복사'
[&n]      (int x){ n += x; }              // n 을 '참조' (원본이 바뀜)
[=]       (int x){ return x * n; }        // 쓰는 것 전부 복사 ⚠
[&]       (int x){ n += x; }              // 쓰는 것 전부 참조 ⚠
[n, &s]   (int x){ s += std::to_string(n); }   // 섞어서 ★ 권장
[s = std::move(s)] (){ use(s); }          // 초기화 캡처 (C++14) — 이동
[this]    (){ return member_; }           // 멤버에 접근
[*this]   (){ return member_; }           // 객체를 통째로 복사 (C++17) ★

// 반환 타입은 대개 추론되지만, 명시할 수도 있습니다
auto f = [](int x) -> double { return x / 2.0; };

// mutable — 복사한 것을 수정하려면
auto counter = [n]() mutable { return ++n; };   // 람다 안의 사본이 증가

// 제네릭 람다 (C++14/20)
auto g = [](const auto& a, const auto& b){ return a < b; };
auto h = []<class T>(const std::vector<T>& v){ return v.size(); };  // C++20

참조 캡처의 함정 ★

// ❌ 지역 변수를 참조로 캡처하고 밖으로 내보내기
std::function<int()> make_bad() {
    int local = 42;
    return [&local]{ return local; };     // local 이 사라진 뒤 호출됨 → UB
}

// ❌ 비동기·스레드에 참조 캡처
void schedule() {
    std::string msg = "안녕";
    pool.submit([&msg]{ log(msg); });     // schedule 이 먼저 끝나면 댕글링
}

// ✅ 값으로 캡처하거나 이동
pool.submit([msg]{ log(msg); });           // 복사
pool.submit([msg = std::move(msg)]{ log(msg); });   // 이동 ★

// ⚠ [=] 는 this 를 '포인터로' 캡처합니다 (C++20 에서 deprecated — 동작은 그대로)
class Widget {
    int n_ = 0;
public:
    auto get() {
        return [=]{ return n_; };          // ❌ 사실은 this 포인터 캡처
        return [*this]{ return n_; };      // ✅ 객체 복사 (C++17)
        return [n = n_]{ return n; };      // ✅ 값만 복사
    }
};

// 규칙 — 람다가 그 자리에서 바로 쓰이면 [&] 도 괜찮지만,
//        저장·전달·비동기라면 반드시 값 캡처 ★

인터페이스에 무엇을 쓸까

// 콜백을 멤버로 보관할 때의 수명 문제
class Button {
    std::function<void()> on_click_;
public:
    void set_handler(std::function<void()> f) { on_click_ = std::move(f); }
};
// ⚠ 핸들러가 다른 객체를 참조로 캡처했는데 그 객체가 먼저 죽으면?
//   → weak_ptr 로 캡처해 살아 있는지 확인하는 패턴 ★
btn.set_handler([w = std::weak_ptr(self)]{
    if (auto s = w.lock()) s->do_something();
});

성능 비교

// 1억 번 호출 시의 경향 (직접 재세요)
//   직접 호출          1.0×   기준
//   템플릿 + 람다       1.0×   완전히 인라인됩니다 ★
//   함수 포인터         1.5×   간접 호출
//   std::function      3~10×  간접 + 할당 가능성 ★
//   가상 함수          1.5~2×

// 확인 — 캡처 크기에 따라 힙 할당 여부가 갈립니다
std::function<void()> f1 = []{};                    // 할당 없음 (SBO)
std::function<void()> f2 = [a,b,c,d,e]{};           // 힙 할당 가능 ★
//   libstdc++ 는 16바이트까지 내부 저장, 그 이상은 힙

// 핫 루프에서 std::function 을 쓰고 있다면
//   ① 템플릿으로 바꾸거나
//   ② 루프 밖으로 빼서 호출 자체를 줄이거나
//   ③ 배열 단위로 처리하는 인터페이스로 바꾸세요
void apply(std::span<double> v, std::function<double(double)> f);  // ❌ 원소마다
void apply_scale(std::span<double> v, double k);                    // ✅ 통째로

이름 없는 클래스입니다

int n = 5;
auto f = [n](int x){ return x + n; };

// 컴파일러가 만드는 것 — 대략 이런 클래스입니다
class __lambda_1 {
    int n_;                                    // 캡처한 것이 멤버
public:
    explicit __lambda_1(int n) : n_(n) {}
    int operator()(int x) const { return x + n_; }   // ★ 기본이 const
};
//   mutable 을 붙이면 operator() 의 const 가 빠집니다

sizeof(f);          // 4 (캡처한 int 하나)
sizeof([]{});       // 1 (빈 클래스도 1바이트)

// 캡처 없는 람다는 함수 포인터로 변환됩니다 ★ (C API 콜백에 유용)
int (*fp)(int) = [](int x){ return x * 2; };
c_api_register(fp);
//   캡처가 있으면 불가능합니다 → void* user 로 상태를 넘기세요(🔗 f08)

// 상태를 전역에 두는 꼼수는 쓰지 마세요 (스레드 안전하지 않음)

인라인화와 최적화

// 템플릿에 람다를 넘기면 '타입이 유일'해 완전히 인라인됩니다
template<class F> void each(std::span<int> v, F f) { for (int& x : v) f(x); }
each(v, [](int& x){ x *= 2; });
//   → 컴파일 결과는 손으로 쓴 루프와 동일합니다 (godbolt 로 확인 가능) ★

// std::function 으로 받으면 타입이 소거되어 인라인이 불가능합니다
void each(std::span<int> v, std::function<void(int&)> f);
//   → 매 원소마다 간접 호출 + 벡터화 실패

// 확인
// g++ -O2 -S 로 어셈블리를 보거나
// godbolt.org 에서 두 버전을 나란히 비교

// 람다 캡처의 숨은 비용
auto f = [big = std::vector<double>(1000)]{ ... };   // 람다 객체가 큽니다
sizeof(f);                                            // 24 (vector 크기)
std::function<void()> g = f;                          // ★ 힙 할당 발생

// 캡처를 shared_ptr 로 줄이는 기법
auto data = std::make_shared<std::vector<double>>(1000);
auto f2 = [data]{ use(*data); };                      // 캡처는 포인터 하나

함수·클래스 템플릿

// 함수 템플릿 — 타입은 대개 추론됩니다
template<class T>
T max_of(const T& a, const T& b) { return a < b ? b : a; }

max_of(1, 2);            // T = int
max_of(1.5, 2.5);        // T = double
max_of<double>(1, 2.5);  // 명시

// 클래스 템플릿
template<class T, std::size_t N>
class FixedBuffer {
    std::array<T, N> data_{};
public:
    T& operator[](std::size_t i) { return data_[i]; }
    constexpr std::size_t size() const noexcept { return N; }
};
FixedBuffer<double, 128> buf;

// C++17 — 클래스 템플릿도 추론됩니다
std::vector v{1, 2, 3};              // vector<int>
std::pair p{1, "a"};                 // pair<int, const char*>

// 가변 인자 템플릿
template<class... Args>
void log(const char* fmt, Args&&... args) {
    std::printf(fmt, std::forward<Args>(args)...);
}

// 폴드 표현식 (C++17) — 인자를 접습니다
template<class... Ts>
auto sum(Ts... xs) { return (xs + ...); }        // (1 + (2 + (3)))
template<class... Ts>
bool all_true(Ts... xs) { return (xs && ...); }

헤더에 둬야 하는 이유

// ❌ 템플릿 정의를 .cpp 에 두면 링크 에러가 납니다
// util.h
template<class T> T twice(T x);        // 선언만
// util.cpp
template<class T> T twice(T x) { return x*2; }
// main.cpp
twice(3);        // undefined reference to twice<int>(int) ★

// 왜? 컴파일러는 'T = int' 인 버전을 실제로 만들어야 하는데,
//     정의가 다른 번역 단위에 있으면 볼 수 없습니다.

// ✅ 방법 ① 헤더에 전부 (가장 흔함)
// util.h
template<class T> T twice(T x) { return x * 2; }

// ✅ 방법 ② 쓸 타입을 미리 지정 (명시적 인스턴스화)
// util.cpp
template int    twice<int>(int);
template double twice<double>(double);
//   → 헤더는 선언만 두고, 빌드 시간을 줄일 수 있습니다

// ✅ 방법 ③ 구현을 별도 헤더로 분리하는 관습
// util.h  →  #include "util.ipp" (또는 .tpp) 를 맨 아래에

판단 기준

// 타입 소거로 빌드 시간을 줄이는 절충안
// 헤더에는 얇은 템플릿만, 실제 구현은 .cpp 의 비템플릿 함수로
void process_impl(const void* data, std::size_t n, int type_tag);  // .cpp

template<class T>
void process(std::span<const T> v) {                    // 헤더
    process_impl(v.data(), v.size(), type_tag_of<T>());
}
//   → 인스턴스화되는 코드가 아주 작아집니다 ★

빌드 시간·바이너리 크기 관리

// ① 명시적 인스턴스화로 중복 컴파일 막기
// matrix.h
extern template class Matrix<double>;     // ★ "여기서 만들지 마"
// matrix.cpp
template class Matrix<double>;            // 여기서 한 번만

// ② 템플릿 매개변수 수를 줄이기
template<class T, class Alloc, class Policy, int N>   // ❌ 조합 폭발
template<class T>                                     // ✅

// ③ 타입에 무관한 부분은 기반 클래스로 빼기 (코드 팽창 방지)
class MatrixBase { protected: void common_logic(); };  // 비템플릿
template<class T> class Matrix : MatrixBase { ... };

// ④ 측정
clang++ -ftime-trace -c matrix.cpp        // 어느 템플릿이 오래 걸리는지
nm -C --size-sort -S app | tail -20       // 어느 인스턴스가 큰지
bloaty app                                 // 섹션별 크기 분석

2단계 이름 조회

// 템플릿은 두 시점에 이름을 찾습니다
//   ① 정의 시점 — T 에 의존하지 않는 이름
//   ② 인스턴스화 시점 — T 에 의존하는 이름 (+ ADL)

template<class T>
void f(T t) {
    helper(t);          // ★ ② 시점에 ADL 로 찾습니다 → 나중에 정의해도 됨
    g();                // ① 시점에 찾습니다 → 앞에 선언이 있어야 함
}

// 의존 타입에는 typename 이 필요합니다
template<class T>
void g(T c) {
    typename T::value_type x;         // ★ typename 없으면 파싱 에러
    typename T::template rebind<int> r;   // 중첩 템플릿에는 template 도
}
//   C++20 부터 많은 자리에서 typename 이 선택적이 됐습니다

// 기반 클래스가 템플릿이면 멤버를 못 찾습니다
template<class T> struct Base { int n; };
template<class T> struct Derived : Base<T> {
    void f() {
        n = 1;              // ❌ 못 찾습니다 (의존 기반이라)
        this->n = 1;        // ✅
        Base<T>::n = 1;     // ✅
    }
};

SFINAE 에서 컨셉으로

// 옛 방식 — SFINAE (Substitution Failure Is Not An Error)
template<class T,
         class = std::enable_if_t<std::is_integral_v<T>>>
void f(T x);                       // 정수일 때만 후보에 들어감
//   읽기 어렵고 에러 메시지가 최악입니다

template<class T>
auto size_of(const T& c) -> decltype(c.size()) { return c.size(); }
//   표현식 SFINAE — c.size() 가 유효할 때만

// C++20 컨셉 — 같은 일을 읽을 수 있게 (m09) ★
template<std::integral T> void f(T x);

template<class T>
concept Sized = requires(const T& c) { { c.size() } -> std::convertible_to<std::size_t>; };
template<Sized T> auto size_of(const T& c) { return c.size(); }

// CRTP — 정적 다형성 (가상 함수 없이)
template<class Derived>
struct Shape {
    double area() const { return static_cast<const Derived*>(this)->area_impl(); }
};
struct Circle : Shape<Circle> {
    double area_impl() const { return 3.14159 * r * r; }
    double r;
};
//   가상 호출 비용 0 · 완전히 인라인됩니다
//   ⚠ 대신 런타임 다형성은 못 합니다 (컨테이너에 섞어 담을 수 없음)
//   C++23 deducing this 로 더 간단해졌습니다

쓰는 법

#include <concepts>

// 표준 컨셉을 그대로 쓰기
template<std::integral T>
T twice(T x) { return x * 2; }

twice(3);      // ✅
twice(3.5);    // ❌ error: constraints not satisfied
               //    note: 'double' does not satisfy 'integral'  ★ 한 줄

// 여러 표기법 (전부 같은 뜻)
template<std::integral T> void f(T);
template<class T> requires std::integral<T> void f(T);
template<class T> void f(T) requires std::integral<T>;
void f(std::integral auto x);                    // ★ 가장 짧은 형태

// 자주 쓰는 표준 컨셉
std::integral · std::floating_point · std::same_as<T>
std::convertible_to<T> · std::derived_from<T>
std::equality_comparable · std::totally_ordered
std::copyable · std::movable · std::default_initializable
std::invocable<Args...> · std::predicate<Args...>
std::ranges::range · random_access_range · contiguous_range

직접 만들기

// requires 식으로 "무엇이 가능해야 하는가" 를 적습니다
template<class T>
concept Drawable = requires(const T& t, Canvas& c) {
    t.draw(c);                                   // 이 호출이 유효해야 함
    { t.bounds() } -> std::convertible_to<Rect>; // 반환 타입까지 검사 ★
    typename T::style_type;                      // 이 중첩 타입이 있어야 함
    requires std::copyable<T>;                   // 다른 컨셉을 요구
};

template<Drawable T>
void render(const T& obj) { obj.draw(canvas); }

// 조합
template<class T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template<class T>
concept SmallNumeric = Numeric<T> && (sizeof(T) <= 4);

// 오버로드 선택에도 쓰입니다 — 더 제약이 강한 쪽이 선택됩니다 ★
void g(std::integral auto x)          { std::puts("정수"); }
void g(std::floating_point auto x)    { std::puts("실수"); }
void g(auto x)                        { std::puts("기타"); }
g(1);      // "정수"
g(1.0);    // "실수"
g("a");    // "기타"

가상 함수 대신 컨셉

// 런타임에 갈아끼울 필요가 없다면 컨셉이 더 낫습니다
template<class T>
concept Storage = requires(T& s, std::string_view k, std::span<const std::byte> v) {
    { s.save(k, v) }  -> std::same_as<void>;
    { s.load(k) }     -> std::convertible_to<std::vector<std::byte>>;
    { s.exists(k) }   -> std::convertible_to<bool>;
};

template<Storage S>
void backup(S& storage, const Data& d) {
    storage.save("backup", serialize(d));
}
//   ✅ 가상 호출 0 · 완전히 인라인 · 상속 불필요
//   ❌ 런타임에 구현을 바꿀 수 없고, 컨테이너에 섞어 담을 수 없습니다

// 둘 다 필요하면 — 컨셉으로 제약하고 타입 소거 래퍼를 따로
class AnyStorage {                     // 런타임 다형성이 필요한 곳에서만
    struct Base { virtual ~Base() = default; virtual void save(...) = 0; };
    template<Storage S> struct Impl : Base { S s; void save(...) override {...} };
    std::unique_ptr<Base> p_;
public:
    template<Storage S> AnyStorage(S s) : p_(std::make_unique<Impl<S>>(std::move(s))) {}
    void save(...) { p_->save(...); }
};

도입 순서

• ① 표준 컨셉부터 — std::integral·std::ranges::range 를 기존 템플릿에 붙이는 것만으로 효과가 큽니다
• ② 자주 반복되는 제약을 이름으로 — requires 식이 두 곳 이상에 나오면 컨셉으로 뽑으세요
• ③ public 인터페이스에 — 라이브러리 사용자가 받는 에러 메시지가 곧 문서입니다
• ④ 과하게 만들지 마세요 — 컨셉이 너무 촘촘하면 정당한 타입까지 막습니다. 실제로 쓰는 연산만 요구하세요

// ⚠ 흔한 과잉 — 실제로 안 쓰는 것까지 요구
template<class T>
concept Bad = std::copyable<T> && std::default_initializable<T>
           && std::equality_comparable<T> && ...;   // 다 필요한가?

// ✅ 함수가 실제로 하는 것만
template<class T>
concept Good = requires(const T& a, const T& b) { { a < b } -> std::convertible_to<bool>; };

포함 관계와 오버로드 선택

// 컨셉은 '더 제약이 강한 쪽'이 선택됩니다 (subsumption)
template<class T> concept A = std::integral<T>;
template<class T> concept B = A<T> && sizeof(T) == 4;

void f(A auto);      // ①
void f(B auto);      // ②
f(int{});            // ② — B 가 A 를 포함하므로 더 구체적

// ⚠ 포함 관계는 '컨셉의 원자적 구성'으로 판단합니다.
//   같은 뜻이어도 다른 식으로 쓰면 포함 관계가 성립하지 않습니다
template<class T> concept C1 = sizeof(T) > 2;
template<class T> concept C2 = C1<T> && sizeof(T) < 8;
//   → C2 가 C1 을 포함합니다 (C1 을 이름으로 재사용하므로) ✅
//     sizeof(T) > 2 를 글자 그대로 다시 적으면 '다른 원자식'이라 포함 안 됩니다
template<class T> concept D1 = (sizeof(T) > 2);
template<class T> concept D2 = (sizeof(T) >= 3);
//   → 수학적으로 같지만 포함 관계가 아닙니다 → ambiguous 에러 ★

// requires 절 안의 requires 식 (헷갈리는 이중 requires)
template<class T>
    requires requires(T t) { t.foo(); }      // 첫 requires=절, 둘째=식
void g(T t);

검사되지 않는 것들

// ① 컨셉은 '문법적 요구'만 검사합니다. 의미는 검사하지 않습니다.
template<class T>
concept Comparable = requires(T a, T b) { { a < b } -> std::convertible_to<bool>; };
//   a < b 가 컴파일된다는 것만 보장합니다.
//   그것이 '순서 관계'로서 올바른지(추이성 등)는 검사할 수 없습니다 ★
//   → 표준은 이런 요구를 '의미 요구사항'으로 문서에 적습니다

// ② requires 식은 '컴파일 되는가'만 봅니다. 실행하지 않습니다.
requires(T t) { t.dangerous(); };   // 실제로 부르지 않습니다

// ③ 컨셉 자체는 런타임 비용이 0 입니다 (전부 컴파일 시점)

// 디버깅 — 컨셉이 왜 만족되지 않는지 확인
static_assert(std::ranges::range<MyType>);       // 어디서 실패하는지 좁히기
static_assert(requires(MyType m){ m.begin(); }); // 단계별로 나눠서

// 컴파일러가 알려 주는 정도가 다릅니다
//   GCC   : note 로 실패한 절을 짚어 줍니다 (-fconcepts-diagnostics-depth=3 로 더 깊게)
//   Clang : 더 자세한 편
//   MSVC  : /diagnostics:caret

optional — 있거나 없거나

#include <optional>
#include <charconv>     // from_chars

std::optional<int> to_int(std::string_view s) {
    int v{};
    auto [p, ec] = std::from_chars(s.data(), s.data()+s.size(), v);
    if (ec != std::errc{}) return std::nullopt;      // 실패
    return v;                                        // 성공
}

if (auto n = to_int(text)) {          // ★ if 안에서 바로
    use(*n);                          // 역참조로 값 꺼내기
}
int v = to_int(text).value_or(0);     // 기본값
to_int(text).value();                 // 없으면 std::bad_optional_access 예외

// 파이썬 None 과 같은 자리지만 '타입에 드러난다'는 점이 다릅니다
//   파이썬: def find(k) -> int | None   ← 힌트일 뿐
//   C++  : std::optional<int> find(K k) ← 안 꺼내면 컴파일이 안 됩니다 ★

// 모나딕 연산 (C++23) — 체이닝
auto r = to_int(text)
    .transform([](int n){ return n * 2; })     // 값이 있으면 변환
    .and_then(validate)                        // optional 을 반환하는 함수
    .or_else([]{ return std::optional{0}; });  // 없으면 대체

// ⚠ optional<T> 는 T 만큼 + 1바이트(+패딩) 커집니다
sizeof(std::optional<double>);   // 16 (8 + 1 + 패딩 7)
//   참조는 담을 수 없습니다 → std::optional<std::reference_wrapper<T>> 또는 T*

variant — 여럿 중 하나

#include <variant>

using Value = std::variant<int, double, std::string>;

Value v = 42;
v = 3.14;
v = "안녕"s;

// ① index / holds_alternative 로 확인
if (std::holds_alternative<int>(v)) use(std::get<int>(v));
if (auto* p = std::get_if<double>(&v)) use(*p);    // ★ 예외 없이 안전

// ② visit — 모든 경우를 처리해야 컴파일됩니다 ★
std::visit(overloaded{
    [](int i)                { std::printf("정수 %d\n", i); },
    [](double d)             { std::printf("실수 %f\n", d); },
    [](const std::string& s) { std::printf("문자열 %s\n", s.c_str()); },
}, v);
//   경우를 빠뜨리면 컴파일 에러 — switch 의 default 누락 같은 실수가 막힙니다

// 상속 대신 쓰기 — 종류가 '고정'되어 있을 때 (기초 탭 x08)
using Shape = std::variant<Circle, Rect, Triangle>;
double area(const Shape& s) {
    return std::visit([](const auto& x){ return x.area(); }, s);
}
//   ✅ 힙 할당 없음 · 가상 호출 없음 · 인라인 가능
//   ❌ 종류를 나중에 추가하려면 이 파일을 고쳐야 합니다

sizeof(Value);   // 가장 큰 대안 + 태그 (여기서는 string 크기 + 8)

계층별로 나눕니다

// ① 안쪽(도메인 로직) — expected 로 실패를 값으로
std::expected<Order, OrderError> make_order(const Request&);

// ② 중간(조합) — 그대로 전파, 체이닝
std::expected<Receipt, OrderError> checkout(const Request& r) {
    return make_order(r)
        .and_then(reserve_stock)
        .and_then(charge)
        .transform(make_receipt);
}

// ③ 경계(HTTP·FFI·파이썬) — 최종 변환 ★
extern "C" int32_t api_checkout(const char* json) {
    auto r = checkout(parse(json));
    if (!r) return to_error_code(r.error());       // 🔗 f09
    return 0;
}
// 파이썬 바인딩이라면
m.def("checkout", [](const Request& r) {
    auto res = checkout(r);
    if (!res) throw py::value_error(to_string(res.error()));  // 🐍 y08
    return *res;
});

// ★ 원칙: 예외는 '진짜 예외적인 것'에만, 흔한 실패는 expected 로.
//   그리고 언어 경계에서는 반드시 그 언어의 관용구로 변환합니다.

에러 타입 설계

// ❌ 문자열만 — 프로그램이 판단할 수 없습니다
std::expected<T, std::string> f();

// ✅ 코드 + 맥락
struct Error {
    enum class Code { NotFound, Invalid, Timeout, Internal } code;
    std::string detail;                      // 사람용 메시지
    std::source_location where =
        std::source_location::current();     // ★ C++20 — 어디서 났는지
};
std::expected<T, Error> f();

// 여러 계층의 에러를 합치기
using AnyError = std::variant<ParseError, IoError, NetError>;

// 로깅
void log(const Error& e) {
    std::printf("[%s:%u] %s\n",
        e.where.file_name(), e.where.line(), e.detail.c_str());
}

// ⚠ [[nodiscard]] 를 꼭 붙이세요 — 결과 무시를 막습니다 ★
[[nodiscard]] std::expected<T, Error> f();
f();      // warning: 반환값이 무시됨

얼마나 커지나

sizeof(int);                                  // 4
sizeof(std::optional<int>);                   // 8  (4 + bool + 패딩)
sizeof(std::optional<double>);                // 16
sizeof(std::optional<std::string>);           // 40 (32 + 8)

sizeof(std::variant<int, double>);            // 16 (8 + 태그 + 패딩)
sizeof(std::variant<int, std::string>);       // 40

sizeof(std::expected<int, int>);              // 8
sizeof(std::expected<std::string, Error>);    // 둘 중 큰 것 + 태그

// ★ optional 은 '빈 상태'를 별도 플래그로 표현합니다.
//   포인터처럼 이미 '없음'을 표현할 수 있는 타입은 낭비입니다
std::optional<T*>         // ❌ 16바이트 — 그냥 T* 를 쓰세요 (nullptr)
std::optional<std::string_view>  // ❌ 대개 빈 view 로 충분

// variant 는 가장 큰 대안의 크기를 차지합니다
std::variant<char, BigStruct>   // BigStruct 크기 + 태그 ★
//   → 큰 대안은 unique_ptr 로 감싸세요
std::variant<char, std::unique_ptr<BigStruct>>

visit 의 구현과 성능

// std::visit 은 대개 '점프 테이블'로 컴파일됩니다
//   대안이 적으면(2~4개) 컴파일러가 if-else 체인으로 펼치기도 합니다
//   → 가상 호출과 비슷하거나 더 빠릅니다 (인라인 가능성이 있으므로)

// ⚠ 여러 variant 를 동시에 visit 하면 조합 폭발
std::visit(f, v1, v2);    // 대안이 각각 5개면 25개 분기가 생성됩니다 ★

// valueless_by_exception — 드물지만 알아 둘 것
//   대입 중 예외가 나면 variant 가 '아무 값도 없는' 상태가 될 수 있습니다
if (v.valueless_by_exception()) { /* 복구 */ }
//   → 이동 생성자가 noexcept 면 거의 발생하지 않습니다

// 성능 비교 (경향 — 직접 재세요)
//   variant + visit  : 인라인 가능 · 힙 할당 없음 · 캐시 유리 ★
//   virtual          : 간접 호출 · 힙 할당 · 포인터 추적
//   → 종류가 고정이면 variant 가 대개 빠릅니다

// 재귀 자료구조는 간접 참조가 필요합니다
struct Json;
using JsonValue = std::variant<std::nullptr_t, bool, double, std::string,
                               std::vector<Json>,
                               std::map<std::string, Json>>;
struct Json { JsonValue v; };      // ★ variant 안에 자기 자신을 직접 못 넣습니다

무엇이 좋아지나

#include <string_view>

// ❌ 예전 — 호출할 때마다 문자열이 만들어집니다
void log(const std::string& msg);
log("리터럴");            // const char* → std::string 임시 생성 (할당!) ★

// ✅ string_view — 포인터와 길이만 넘깁니다 (할당 0)
void log(std::string_view msg);
log("리터럴");            // 할당 없음
log(s);                   // std::string 도 그대로
log({buf, n});            // 버퍼 일부도

sizeof(std::string_view);  // 16 (포인터 8 + 길이 8)

// 부분 문자열도 복사 없이
std::string_view sv = text;
sv.substr(0, 10);         // ★ 새 문자열을 만들지 않습니다 (창만 좁힘)
text.substr(0, 10);       // 반면 이건 새 string 을 할당합니다

// 쓸 수 있는 것
sv.size()  sv.empty()  sv[i]  sv.front()  sv.back()
sv.find("x")  sv.starts_with("a")  sv.ends_with("z")   // C++20
sv.remove_prefix(3);  sv.remove_suffix(2);
for (char c : sv) ...

// 못 하는 것 — 내용 수정 (읽기 전용입니다)
sv[0] = 'x';              // ❌ 컴파일 에러

수명 함정 ★

// ❌ ① 임시 문자열을 가리키기
std::string_view sv = get_name() + "님";     // 임시가 식 끝에 사라짐 → 댕글링
std::string_view sv = std::to_string(42);    // 같은 문제

// ❌ ② 멤버로 보관
class Bad {
    std::string_view name_;                  // 원본이 먼저 죽으면?
public:
    explicit Bad(std::string_view n) : name_(n) {}
};
Bad b{std::string("임시")};                   // ❌ 생성 직후 댕글링

// ❌ ③ 컨테이너가 재할당되면
std::vector<std::string> v{"a"};
std::string_view sv = v[0];
v.push_back("b");                            // 재할당 → sv 무효

// ❌ ④ 널 종료가 보장되지 않습니다
void c_api(const char*);
c_api(sv.data());                            // ❌ 뒤에 다른 내용이 이어질 수 있음
c_api(std::string(sv).c_str());              // ✅ 복사해서 넘기기

// ✅ 규칙
//   · 함수 '인자'로만 쓰세요 (그 호출 동안만 유효하면 됨) ★
//   · 보관해야 하면 std::string 으로 복사
//   · 반환하지 마세요 (인자로 받은 것을 그대로 돌려주는 경우만 예외)

무엇을 언제 쓰나

class Config {
    std::string host_;                                   // 멤버는 string
public:
    explicit Config(std::string host)                    // 보관 → 값 + move
        : host_(std::move(host)) {}

    [[nodiscard]] std::string_view host() const noexcept  // 읽기 → view
        { return host_; }

    bool matches(std::string_view pattern) const;        // 인자 → view
};

문자열 조립 최적화

// ❌ + 연산자 체인 — 중간 임시가 여러 개 생깁니다
std::string s = a + "-" + b + "-" + c;

// ✅ 미리 잡고 이어 붙이기
std::string s;
s.reserve(a.size() + b.size() + c.size() + 2);
s += a; s += '-'; s += b; s += '-'; s += c;

// ✅✅ std::format (C++20) — 한 번에, 읽기도 좋습니다 ★
std::string s = std::format("{}-{}-{}", a, b, c);

// 반복 조립은 back_inserter 로
std::string out;
std::format_to(std::back_inserter(out), "{}: {}\n", key, value);

// 미리 크기 계산 (C++20)
auto n = std::formatted_size("{}-{}", a, b);

// 여러 조각 합치기
std::vector<std::string_view> parts{...};
std::string joined;
joined.reserve(std::accumulate(parts.begin(), parts.end(), std::size_t{0},
    [](std::size_t n, auto sv){ return n + sv.size() + 1; }));
for (auto sv : parts) { joined += sv; joined += ','; }

작은 문자열 최적화

// std::string 은 짧으면 힙을 안 씁니다 (객체 안에 직접 저장)
//   libstdc++ : 15바이트까지    libc++ : 22바이트까지    MSVC : 15바이트
sizeof(std::string);        // 32 (libstdc++)

// 확인 — 할당 횟수를 세어 보기
static int allocs = 0;
void* operator new(std::size_t n) { ++allocs; return std::malloc(n); }

std::string a = "짧음";              // 할당 0
std::string b(100, 'x');             // 할당 1

// ★ 성능이 '계단식'으로 변하는 이유
//   키 길이가 15바이트를 넘는 순간 map 삽입 비용이 갑자기 뜁니다
//   → 로그 태그·enum 이름처럼 짧은 문자열은 생각보다 쌉니다

// 한글은 3바이트라 6글자부터 SSO 를 넘습니다 (libstdc++·MSVC) ★
std::string k = "안녕하세요";        // 15바이트 — 경계선 (아직 SSO, 한 글자 더하면 할당)

// 대안 — 고정 크기 문자열
template<std::size_t N> struct FixedString {
    std::array<char, N> data{};
    std::uint8_t len{};
};
//   할당이 절대 없고 캐시에 잘 맞습니다 (게임·거래 시스템에서 씁니다)

비교와 해시 비용

// map<string, T> 에 string_view 로 조회하기 — 임시 string 없이 ★
std::map<std::string, int, std::less<>> m;     // ★ std::less<> (투명 비교자)
m.find(std::string_view{"key"});                // 할당 없이 조회

struct StringHash {
    using is_transparent = void;                // ★ 이 표시가 필요합니다
    std::size_t operator()(std::string_view sv) const {
        return std::hash<std::string_view>{}(sv);
    }
    std::size_t operator()(const std::string& s) const {
        return std::hash<std::string>{}(s);
    }
};
std::unordered_map<std::string, int, StringHash, std::equal_to<>> um;
um.find(std::string_view{"key"});               // C++20 — 할당 없음

// 문자열 인터닝 — 같은 문자열을 한 번만 저장하고 포인터로 비교
class Interner {
    std::unordered_set<std::string> pool_;
public:
    std::string_view intern(std::string_view sv) {
        return *pool_.emplace(sv).first;        // 참조가 안정적입니다
    }
};
//   비교가 포인터 비교로 줄어 파서·심볼 테이블에서 큰 이득

스레드 만들고 기다리기

#include <thread>
#include <mutex>

// C++20 jthread — 소멸자가 join 합니다 ★ (thread 는 terminate)
{
    std::jthread t([]{ work(); });
}   // 여기서 자동으로 join

// 취소까지 지원
std::jthread t([](std::stop_token st){
    while (!st.stop_requested()) { step(); }
});
t.request_stop();

// 공유 데이터는 반드시 보호
std::mutex m;
int counter = 0;
void inc() {
    std::lock_guard lk(m);       // RAII — 예외가 나도 풀립니다 ★
    ++counter;
}

// 여러 뮤텍스를 한 번에 (교착 방지)
std::scoped_lock lk(m1, m2);     // C++17 — 순서를 알아서 정합니다

// 조건 변수 — "무언가 준비될 때까지 기다리기"
std::condition_variable cv;
std::unique_lock lk(m);
cv.wait(lk, []{ return ready; });    // ★ 술어를 반드시 주세요 (가짜 깨움 방지)
cv.notify_one();  cv.notify_all();

더 쉬운 방법부터

// ① 병렬 알고리즘 — 스레드를 직접 안 만들어도 됩니다 ★
#include <execution>
std::sort(std::execution::par, v.begin(), v.end());
std::transform(std::execution::par_unseq, a.begin(), a.end(), out.begin(), f);

// ② async / future — 결과를 나중에 받기
#include <future>
auto fut = std::async(std::launch::async, []{ return heavy(); });
auto r = fut.get();              // 완료될 때까지 대기 (예외도 여기서 전달)

// ③ atomic — 락 없이 간단한 값 공유
std::atomic<int> done{0};
done.fetch_add(1, std::memory_order_relaxed);
std::atomic<bool> stop{false};

// ④ 스레드 로컬
thread_local std::vector<double> scratch;    // 스레드마다 별도 버퍼 ★

// ⑤ 동기화 도구 (C++20)
std::latch  latch{4};   latch.count_down();  latch.wait();
std::barrier bar{4};    bar.arrive_and_wait();
std::counting_semaphore<10> sem{3};

GIL 을 놓으면 진짜로 병렬입니다

// 🐍 y07 과 이어지는 내용 — GIL 을 놓는 순간
// 파이썬이 제공하던 '어쩌다 직렬화'가 사라집니다.

// ❌ 전역 상태 — GIL 이 있을 때는 우연히 안전했습니다
static std::vector<double> g_cache;
m.def("run", [](py::array_t<double> a) {
    py::gil_scoped_release rel;
    g_cache.push_back(...);            // ★ 이제 진짜 데이터 경쟁
});

// ✅ 상태를 객체 안으로
py::class_<Engine>(m, "Engine")
    .def("run", &Engine::run, py::call_guard<py::gil_scoped_release>());
//   서로 다른 Engine 인스턴스는 독립적입니다
//   문서에 "같은 인스턴스를 여러 스레드에서 쓰지 마세요" 라고 명시

// ✅ 꼭 공유해야 하면 직접 보호
class Engine {
    mutable std::shared_mutex mx_;     // 읽기는 동시에, 쓰기는 배타적
    std::vector<double> data_;
public:
    double get(int i) const {
        std::shared_lock lk(mx_);      // 여러 스레드가 동시에 읽기 ★
        return data_[i];
    }
    void set(int i, double v) {
        std::unique_lock lk(mx_);      // 쓸 때만 배타적
        data_[i] = v;
    }
};

스레드 풀을 직접 만들지 마세요

// 표준에는 아직 스레드 풀이 없습니다 (C++26 예정).
// 직접 만들면 종료 처리·예외 전파·작업 훔치기에서 반드시 버그가 납니다.

// ✅ 검증된 것을 쓰세요
//   · std::execution::par (내부적으로 풀을 씁니다) ★ 가장 간단
//   · Intel TBB   — 작업 훔치기 · 성숙함
//   · OpenMP      — 지시문 한 줄
//   · BS::thread_pool — 헤더 하나짜리 경량

#include <BS_thread_pool.hpp>
BS::thread_pool pool(std::thread::hardware_concurrency());
auto fut = pool.submit_task([]{ return heavy(); });
pool.wait();

// ⚠ 스레드 수는 사용자가 정하게 하세요
//   이미 멀티프로세싱으로 도는 환경에서 모든 코어를 잡으면 오히려 느려집니다
m.def("set_threads", [](int n){ get_pool().reset(n); });
//   기본값은 1 이나 환경변수로 (OMP_NUM_THREADS 관례를 따르는 것도 좋습니다)

왜 순서가 뒤바뀌나

// 컴파일러와 CPU 는 성능을 위해 명령 순서를 바꿉니다.
// 단일 스레드에서는 결과가 같지만, 다른 스레드가 보는 순서는 다를 수 있습니다.

// ❌ 고전적인 실패
bool ready = false;
int  data  = 0;
// 스레드 A
data = 42;
ready = true;          // ★ 컴파일러가 이 둘의 순서를 바꿀 수 있습니다
// 스레드 B
if (ready) use(data);  // data 가 아직 0일 수 있습니다

// ✅ atomic 으로 순서를 강제
std::atomic<bool> ready{false};
int data = 0;
// A
data = 42;
ready.store(true, std::memory_order_release);    // 앞의 쓰기를 모두 공개
// B
if (ready.load(std::memory_order_acquire))       // 그 이후를 모두 관찰
    use(data);                                    // ✅ 42 가 보장됩니다

// memory_order 요약
//   seq_cst  기본값 · 가장 안전 · 가장 느림 (전역 순서)
//   acquire/release  생산자-소비자 쌍 ★ 실무에서 쓰는 대부분
//   relaxed  순서 보장 없음 · 카운터처럼 값만 정확하면 될 때
//   → 확신이 없으면 기본값(seq_cst)을 쓰세요. 대개 충분히 빠릅니다.

검증 도구

# ThreadSanitizer — 데이터 경쟁을 실행 중에 잡습니다 ★
g++ -fsanitize=thread -g -O1 app.cpp -o app
./app
#   WARNING: ThreadSanitizer: data race
#     Write of size 8 at 0x... by thread T2:
#       #0 update() app.cpp:42
#     Previous read of size 8 at 0x... by thread T1:
#       #0 read() app.cpp:31
#   → 두 지점을 정확히 짚어 줍니다

# ⚠ ASan 과 함께 못 씁니다 (별도 빌드로 돌리세요)
# ⚠ 실행이 5~15배 느려집니다 → CI 의 별도 잡으로

# 파이썬 확장을 검사하려면
TSAN_OPTIONS="suppressions=tsan.supp" \
  LD_PRELOAD=$(gcc -print-file-name=libtsan.so) python test.py

# 교착 탐지
gdb -p PID -batch -ex "thread apply all bt"     # 모든 스레드가 어디서 멈췄나
# helgrind (valgrind) — 락 순서 문제도 잡습니다
valgrind --tool=helgrind ./app

먼저 이 순서를 다 밟았는지 확인하세요

# ① 진짜 병목이 어디인지 측정  ★ 이걸 건너뛰면 대부분 헛수고입니다
python -m cProfile -s cumtime app.py | head -20
py-spy record -o flame.svg -- python app.py

# ② 알고리즘·자료구조 (O(n²) → O(n))
#    여기서 100배가 나오는 경우가 C++ 로 얻는 것보다 흔합니다

# ③ I/O·쿼리 횟수 줄이기
#    프로파일 1위가 read·recv·execute 면 C++ 로 바꿔도 그대로입니다

# ④ 이미 있는 C 라이브러리로 대체
import numpy as np            # 배열 연산
import polars as pl           # 표 연산 (pandas 보다 빠름)
import scipy, sklearn         # 수치·통계

# ⑤ 파이썬을 그대로 두고 컴파일
#    Cython · mypyc · Numba(@njit) — 코드를 거의 안 바꾸고 수십 배

# ⑥ 그래도 남는 병목 하나 → 여기서 C++ 를 꺼냅니다 ★

C++ 가 실제로 이기는 자리

비용은 코드가 아니라 운영에서 옵니다

• 빌드 환경 — 팀원 전원과 CI 에 컴파일러가 필요합니다. wheel 을 미리 만들어 배포하면 쓰는 사람은 몰라도 됩니다(y03·🛠️ b06)
• 플랫폼 수 × 파이썬 버전 수 = 만들어야 할 wheel 수. abi3 로 묶으면 파이썬 버전별 빌드를 줄일 수 있습니다
• 디버깅 난이도 — 파이썬에서 나던 ValueError 가 세그폴트로 인터프리터 전체가 죽는 형태로 바뀝니다
• 버스 팩터 — 그 모듈을 고칠 수 있는 사람이 팀에 몇 명인지
• 되돌릴 수 있게 — 순수 파이썬 구현을 같이 남겨 두고 환경변수로 전환 가능하게 해 두면 사고 시 즉시 되돌립니다 ★

인터페이스를 먼저 설계합니다

# ❌ 파이썬 객체를 그대로 넘기는 설계 — 경계를 수백만 번 넘습니다
for row in rows:
    result.append(fastmod.process_one(row))     # 호출마다 변환 비용

# ✅ 배열 하나를 통째로 넘기고 결과 배열을 받습니다 ★
result = fastmod.process_all(arr)               # 경계는 단 한 번

# ✅ 상태가 필요하면 객체 하나로 유지 (매번 재구성하지 않기)
engine = fastmod.Engine(config)     # 무거운 준비는 한 번만
for chunk in stream:
    engine.feed(chunk)              # 가벼운 호출

# ✅ 데이터는 numpy 로 주고받습니다 (복사 없이 — y06)
import numpy as np
out = np.empty_like(arr)
fastmod.transform(arr, out)         # 결과를 미리 만든 버퍼에 씁니다

빈 함수를 부르는 데 얼마나 드나

// noop.cpp — 아무것도 안 하는 함수들
#include <pybind11/pybind11.h>
#include <pybind11/numpy.h>
#include <pybind11/stl.h>          // ★ 없으면 take_list 호출이 TypeError
namespace py = pybind11;

void noop() {}
void take_int(int) {}
void take_list(const std::vector<double>&) {}          // 자동 변환 = 복사
void take_arr(py::array_t<double>) {}                   // 버퍼 = 복사 없음

PYBIND11_MODULE(noop, m) {
    m.def("noop", &noop);
    m.def("take_int", &take_int);
    m.def("take_list", &take_list);
    m.def("take_arr", &take_arr);
}

import timeit, numpy as np, noop
a = np.zeros(1_000_000); L = a.tolist()

timeit.timeit(lambda: noop.noop(), number=100_000)
timeit.timeit(lambda: noop.take_arr(a), number=100_000)    # 크기와 무관
timeit.timeit(lambda: noop.take_list(L), number=100)       # ★ 크기에 비례

#  결과의 형태 (숫자는 환경마다 다릅니다 — 직접 재세요)
#    noop        : 호출당 수십~수백 ns
#    take_arr    : 비슷함 (버퍼는 포인터만 넘어감)
#    take_list   : 100만 원소를 매번 vector 로 복사 → 수 ms ★
#  → 자동 변환이 편해 보이지만 '큰 컨테이너'에는 절대 쓰면 안 됩니다

손익분기점을 계산해 두기

# 언제부터 C++ 가 이기는가
#   총시간_py   = n × t_py
#   총시간_cpp  = 경계비용 + n × t_cpp
#   → n × (t_py - t_cpp) > 경계비용  일 때만 이득

# 실제로는 이렇게 재 봅니다
import numpy as np, timeit, fastmod
for n in (100, 1_000, 10_000, 100_000, 1_000_000):
    a = np.random.rand(n)
    tp = timeit.timeit(lambda: pure_python(a), number=10) / 10
    tc = timeit.timeit(lambda: fastmod.run(a),  number=10) / 10
    print(f"{n:>9}  py {tp*1e3:8.3f}ms  cpp {tc*1e3:8.3f}ms  {tp/tc:6.1f}×")

#  전형적인 결과 — 작은 n 에서는 배수가 1 근처이거나 오히려 손해,
#  n 이 커질수록 배수가 올라가다 어느 지점에서 평평해집니다(메모리 대역폭 한계).
#  ★ 이 표를 팀에 보여 주는 것이 "빨라졌습니다"보다 100배 설득력 있습니다

① C++ 파일 하나

// src/fastmod.cpp
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>      // vector ↔ list 자동 변환

namespace py = pybind11;

int add(int a, int b) {
    return a + b;
}

double mean(const std::vector<double>& v) {
    double s = 0;
    for (double x : v) s += x;
    return v.empty() ? 0.0 : s / v.size();
}

PYBIND11_MODULE(fastmod, m) {        // ★ 이름이 파이썬 모듈명과 같아야 합니다
    m.doc() = "느린 부분만 C++ 로";

    m.def("add", &add, "두 정수를 더한다",
          py::arg("a"), py::arg("b"));           // 키워드 인자 이름

    m.def("mean", &mean, "평균을 구한다",
          py::arg("values"));
}

② 빌드 파일 두 개

# pyproject.toml
[build-system]
requires = ["scikit-build-core>=0.10", "pybind11>=2.12"]
build-backend = "scikit_build_core.build"

[project]
name = "fastmod"
version = "0.1.0"
requires-python = ">=3.9"

# CMakeLists.txt
cmake_minimum_required(VERSION 3.20)
project(fastmod LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
find_package(pybind11 CONFIG REQUIRED)

pybind11_add_module(fastmod src/fastmod.cpp)
install(TARGETS fastmod DESTINATION .)

# ③ 설치하고 바로 쓰기
pip install .
#   또는 개발 중이라면 (editable 설치 — 자동 재빌드 설정은 아래 ①)
pip install -e . --no-build-isolation

>>> import fastmod
>>> fastmod.add(1, 2)
3
>>> fastmod.add(a=1, b=2)          # 키워드도 됩니다
3
>>> fastmod.mean([1.0, 2.0, 3.0])  # list 가 vector 로 변환됩니다
2.0
>>> help(fastmod.add)              # docstring 도 나옵니다

C++ 모듈을 파이썬 패키지 안에 감춥니다

fastmod/
  pyproject.toml
  CMakeLists.txt
  src/
    _core.cpp            ← C++ (내부용 이름에 _ 를 붙입니다)
  python/fastmod/
    __init__.py          ← 사용자에게 보이는 얼굴
    _fallback.py         ← 순수 파이썬 구현 (되돌릴 수 있게) ★
    py.typed             ← 타입 힌트 제공 표시
    _core.pyi            ← 스텁 (y10)
  tests/
    test_parity.py       ← C++ 와 파이썬 결과가 같은지 대조 ★

# python/fastmod/__init__.py
import os

_use_pure = os.environ.get("FASTMOD_PURE") == "1"

if not _use_pure:
    try:
        from ._core import mean, smooth        # C++ 구현
    except ImportError:                        # 빌드 안 된 환경
        _use_pure = True

if _use_pure:
    from ._fallback import mean, smooth        # 파이썬 구현

__all__ = ["mean", "smooth"]

정확성을 자동으로 지키기

# tests/test_parity.py
import numpy as np, pytest
from fastmod import _core
from fastmod import _fallback

@pytest.mark.parametrize("n", [0, 1, 2, 1000])
def test_mean_matches(n):
    a = np.random.rand(n)
    assert _core.mean(a) == pytest.approx(_fallback.mean(a), rel=1e-12)

# 속성 기반 테스트 — 랜덤 입력으로 두 구현을 계속 대조합니다 ★
from hypothesis import given, strategies as st
import hypothesis.extra.numpy as hnp

@given(hnp.arrays(np.float64, hnp.array_shapes(max_dims=1),
                  elements=st.floats(-1e6, 1e6)))
def test_smooth_matches(a):
    np.testing.assert_allclose(_core.smooth(a, 3),
                               _fallback.smooth(a, 3), rtol=1e-10)

# 경계 조건은 꼭 따로 — 여기서 세그폴트가 납니다
def test_empty_and_huge():
    assert _core.mean(np.array([])) == 0.0
    _core.smooth(np.zeros(0), 3)
    with pytest.raises(ValueError):
        _core.smooth(np.zeros(10), 0)      # 잘못된 인자는 예외로 ★

PYBIND11_MODULE 이 펼쳐지면

// 이 매크로는 결국 CPython 이 찾는 진입점 함수를 만듭니다
//
//   extern "C" PyObject* PyInit_fastmod() { ... }
//
// import fastmod 를 하면 CPython 이
//   ① sys.path 에서 fastmod*.so 를 찾고
//   ② dlopen 으로 공유 라이브러리를 로드하고
//   ③ PyInit_fastmod 심볼을 찾아 호출하고
//   ④ 돌려받은 모듈 객체를 sys.modules 에 등록합니다

// 확인
nm -D fastmod*.so | grep PyInit_fastmod       // T PyInit_fastmod
python -c "import fastmod, sys; print(sys.modules['fastmod'])"

// ★ 그래서 import 실패의 원인은 대개 이 셋 중 하나입니다
//   · 파일 이름과 모듈 이름 불일치        → PyInit_ 이름이 안 맞음
//   · undefined symbol (링크 누락)        → ldd / nm -D 로 확인
//   · 파이썬 버전·ABI 불일치              → 다른 버전으로 빌드된 .so

ldd fastmod*.so                    // 필요한 라이브러리가 다 있는지
python -c "import fastmod" 2>&1    // ImportError 메시지에 심볼 이름이 나옵니다

모듈 로딩 비용과 바이너리 크기

# 모듈이 얼마나 큰가 · 로딩이 얼마나 걸리는가
ls -lh fastmod*.so
python -X importtime -c "import fastmod" 2>&1 | tail -3

# pybind11 은 템플릿을 많이 써서 바이너리가 커집니다. 줄이는 방법:
#   ① 심볼 가시성 숨기기 (pybind11_add_module 이 이미 해 줍니다)
#   ② 링크 시 안 쓰는 것 제거
target_link_options(fastmod PRIVATE -Wl,--gc-sections)
target_compile_options(fastmod PRIVATE -ffunction-sections -fdata-sections)
#   ③ 릴리즈 빌드에서 디버그 심볼 분리
strip --strip-unneeded fastmod*.so     # 크기가 절반 이하로 줄기도 합니다
#   ④ 크기가 정말 중요하면 nanobind 로 (y11) — 보통 3~10배 작습니다

# 무엇이 크기를 차지하는지
nm -C --size-sort -S fastmod*.so | tail -20
bloaty fastmod*.so                     # 더 자세한 분석

빌드 백엔드 고르기

# pyproject.toml — 실무에서 쓰는 형태
[build-system]
requires = ["scikit-build-core>=0.10", "pybind11>=2.12"]
build-backend = "scikit_build_core.build"

[project]
name = "fastmod"
version = "0.1.0"
requires-python = ">=3.9"
dependencies = ["numpy>=1.23"]

[tool.scikit-build]
wheel.packages = ["python/fastmod"]     # 파이썬 코드 위치
cmake.version = ">=3.20"
build-dir = "build/{wheel_tag}"         # 재빌드 캐시 유지 ★

[tool.scikit-build.cmake.define]
CMAKE_BUILD_TYPE = "Release"

CMake 쪽 — 파이썬을 찾고 모듈을 만듭니다

cmake_minimum_required(VERSION 3.20)
project(fastmod LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)

# scikit-build-core 가 알맞은 파이썬을 알려 줍니다
find_package(Python REQUIRED COMPONENTS Interpreter Development.Module)
find_package(pybind11 CONFIG REQUIRED)

pybind11_add_module(_core src/core.cpp src/algo.cpp)
target_include_directories(_core PRIVATE src)
target_compile_definitions(_core PRIVATE VERSION_INFO=${SKBUILD_PROJECT_VERSION})
#   ↑ scikit-build-core 가 pyproject 의 version 을 넘겨 줍니다
#     (project() 에 VERSION 이 없어 ${PROJECT_VERSION} 은 비어 있습니다)

# 최적화 — 릴리즈에서만
target_compile_options(_core PRIVATE
  $<$<AND:$<CONFIG:Release>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-O3>)

install(TARGETS _core DESTINATION fastmod)   # 패키지 안으로 ★

wheel 을 미리 만들어 올립니다

# .github/workflows/wheels.yml
name: wheels
on: {push: {tags: ['v*']}}

jobs:
  build:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-14]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - uses: pypa/cibuildwheel@v2.21          # ★ 이 액션이 전부 해 줍니다
        env:
          CIBW_BUILD: "cp39-* cp310-* cp311-* cp312-* cp313-*"
          CIBW_SKIP: "*-musllinux_i686 pp*"
          CIBW_TEST_REQUIRES: pytest numpy
          CIBW_TEST_COMMAND: "pytest {project}/tests"
      - uses: actions/upload-artifact@v4
        with: {name: "wheels-${{ matrix.os }}", path: wheelhouse/*.whl}   # v4 는 이름이 겹치면 실패

파이썬 버전마다 빌드하지 않는 법 — abi3

# 안정 ABI(abi3)로 빌드하면 wheel 하나가 여러 파이썬 버전에서 동작합니다
# ⚠ pybind11 은 Py_LIMITED_API(안정 ABI)를 지원하지 않습니다
#   → abi3 가 필요하면 nanobind 로 (파이썬 3.12+, y11)
nanobind_add_module(_core STABLE_ABI src/core.cpp)
#   3.12 미만 파이썬으로 빌드하면 STABLE_ABI 는 무시되고 일반 빌드가 됩니다
#   파일 이름: _core.abi3.so (리눅스/맥) · _core.pyd (윈도우)

# pyproject.toml
[tool.scikit-build]
wheel.py-api = "cp312"       # cp312-abi3 태그로 빌드 (3.12 이상 전부)

비교 — 파이썬 5개 버전(모두 3.12 이상) × 3 OS × 2 아키텍처

  일반 빌드 : 30개 wheel · CI 시간 30분 · 새 파이썬 나오면 다시 빌드
  abi3      :  6개 wheel · CI 시간  6분 · 새 버전에서도 그대로 동작 ★

대가
  · CPython 안정 API 만 쓸 수 있어 일부 최적화가 제한됩니다
  · abi3 는 nanobind + 3.12 이상에서만 — 3.9~3.11 도 지원하려면 그 버전은 따로 빌드합니다
  · 성능 차이는 대개 미미하지만, 극단적으로 호출이 잦으면 재 보세요

pybind11 은 왜 컴파일이 느린가

// 바인딩 코드는 템플릿 인스턴스화가 폭발적으로 일어납니다.
// m.def 하나마다 인자 타입 조합만큼 코드가 생성됩니다.

// ① 바인딩을 여러 파일로 쪼개기 — 병렬 컴파일이 가능해집니다 ★
// bind_array.cpp
void bind_array(py::module_& m) { m.def("smooth", &smooth); }
// bind_stats.cpp
void bind_stats(py::module_& m) { m.def("mean", &mean); }
// main.cpp
PYBIND11_MODULE(_core, m) { bind_array(m); bind_stats(m); }

// ② 실제 로직과 바인딩을 분리 — 로직은 순수 C++ 로 두고 테스트도 C++ 로
//    (바인딩 파일만 느리게 컴파일되고, 로직 파일은 빠릅니다)

// ③ 컴파일 시간 측정
//    clang++ -ftime-trace -c bind_array.cpp  → ui.perfetto.dev

// ④ 링크 시간 최적화는 릴리즈에서만 (개발 중에는 매우 느려집니다)
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)

재현 가능한 빌드

# ① 의존성 버전을 전부 고정
#    pyproject.toml 의 requires 에 상한을 두고
#    FetchContent 는 GIT_TAG 를 커밋 해시로

# ② 빌드 환경을 컨테이너로 고정
docker run --rm -v $PWD:/io quay.io/pypa/manylinux_2_28_x86_64 \
    /io/build_wheels.sh

# ③ 어떤 플래그로 빌드됐는지 wheel 에 기록
#    CMake 에서 컴파일 정보를 모듈 속성으로 노출
target_compile_definitions(_core PRIVATE
    BUILD_INFO="${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
#    파이썬에서 fastmod.__build_info__ 로 확인 → 장애 대응에 유용 ★

# ④ wheel 안에 뭐가 들었는지 확인
unzip -l dist/fastmod-0.1.0-*.whl
auditwheel show dist/*.whl          # 어떤 .so 에 의존하는지 · manylinux 등급

자동으로 변환되는 것들

#include <pybind11/stl.h>        // ★ 이 헤더가 있어야 컨테이너 변환됨

// 파이썬              C++
// int                 int · long · size_t
// float               double · float
// str                 std::string          (UTF-8 로 인코딩)
// bytes               std::string · std::vector<uint8_t>
// bool                bool
// None                std::nullptr_t · optional 의 비어 있음
// list                std::vector<T>       ★ 복사
// tuple               std::tuple · std::pair
// dict                std::map · unordered_map  ★ 복사
// set                 std::set · unordered_set  ★ 복사
// datetime            std::chrono::system_clock::time_point
//                       (<pybind11/chrono.h> 필요)

// ⚠ 복사는 '양방향' 입니다
std::vector<double> process(const std::vector<double>& in);
//   파이썬 list → vector 복사 (들어올 때)
//   vector → 파이썬 list 복사 (나갈 때)
//   100만 원소면 왕복 두 번의 전체 복사입니다 ★

복사를 피하는 세 가지 길

// ① numpy 배열로 주고받기 ★ 가장 중요 (y06 에서 자세히)
#include <pybind11/numpy.h>
double mean(py::array_t<double> a) {
    auto buf = a.request();               // 포인터만 얻습니다 — 복사 없음
    const double* p = static_cast<double*>(buf.ptr);
    ...
}

// ② 파이썬 객체를 그대로 다루기 (변환하지 않음)
void inspect(const py::object& o) {
    py::len(o);
    o.attr("method")();
}
py::list  lst;  py::dict d;              // 파이썬 타입 그대로

// ③ C++ 객체를 참조로 노출 (y05 의 클래스 바인딩)
//    반환 정책으로 '복사할지 참조할지' 정합니다
m.def("get_buffer", &get_buffer,
      py::return_value_policy::reference_internal);   // 복사 없이 참조

C++ 스타일을 그대로 노출하지 않습니다

// ❌ C++ 관습을 그대로 — 파이썬 사용자에게 낯섭니다
m.def("get_result", [](Engine& e, std::vector<double>& out) {
    e.fill(out);                     // 출력 인자
});

// ✅ 파이썬은 '돌려받는' 것이 자연스럽습니다
m.def("get_result", [](Engine& e) {
    std::vector<double> out(e.size());
    e.fill(out);
    return as_numpy(std::move(out));   // numpy 배열로 (복사 없이 이동)
});

// ✅ 예외로 실패를 알립니다 (에러 코드 반환 대신 — y08)
m.def("parse", [](std::string_view s) {
    auto r = parse_impl(s);
    if (!r) throw py::value_error("파싱 실패: " + r.error());
    return *r;
});

// ✅ 이름은 snake_case, 불린 인자는 키워드 전용으로
m.def("smooth", &smooth, "data"_a, py::kw_only(), "window"_a = 3);
//   파이썬: smooth(arr, window=5)   ← 위치로 못 넘기게 강제

문자열과 바이트 다루기

// str ↔ std::string 은 UTF-8 인코딩·디코딩이 일어납니다 (비용 있음)
void f(const std::string& s);        // 파이썬 str → UTF-8 바이트로 복사

// 바이너리 데이터는 bytes 로 — 인코딩 검사가 없어 더 빠릅니다
void g(const py::bytes& b) {
    std::string_view sv = b;          // 복사 없이 들여다보기 (pybind11 2.12+)
}

// 복사 없이 읽기만 할 때 (수명에 주의)
void h(std::string_view sv);          // 파이썬 str 은 임시 버퍼가 생길 수 있습니다
//   ★ 함수가 끝난 뒤에도 보관하려면 반드시 std::string 으로 복사하세요

// 대용량 바이너리는 buffer protocol 로 (복사 0)
void process(py::buffer b) {
    py::buffer_info info = b.request();
    auto* p = static_cast<uint8_t*>(info.ptr);
    // bytes · bytearray · numpy · memoryview 전부 이 경로로 옵니다 ★
}

// 결과를 bytes 로 돌려주기
py::bytes make_packet() {
    std::string buf = build();
    return py::bytes(buf);            // 여기서 한 번 복사됩니다
}