Category
Preparing references and filters for this topic. 이 주제의 레퍼런스와 필터를 준비하고 있습니다.
C에서 기본 타입을 고를 때 `int`와 `stdint.h`를 어디서 나눌지, `double`과 `float`, `const`, `unsigned`의 실전 선택 기준과 흔한 함정을 정리합니다.
#include <stdbool.h>
#include <stdint.h>
int count = 100;
double ratio = 3.1415926535;
bool ready = false;
/* 파일 형식·프로토콜처럼 폭이 계약일 때만 고정 폭 타입을 고른다. */
const int max_size = 256;
uint32_t flags = 0x000000FF;C의 주요 연산자 그룹, 정수 나눗셈, 증가 연산, 단락 평가, 우선순위와 평가 순서의 차이를 정리합니다.
#include <stddef.h>
/* 산술: 정수끼리 나누면 소수점 이하는 버린다. */
int total = 7;
int count = 2;
double ratio = (double)total / count;
/* 논리: 왼쪽이 거짓이면 오른쪽을 평가하지 않는다. */
int value = 1;
int *ptr = &value;
if (ptr != NULL && *ptr > 0) {
value = *ptr;
}
/* 비트: 비교하려는 mask 식 전체를 괄호로 묶는다. */
enum { MASK = 0x04u };
unsigned flags = 0u;
int no_flags = ((flags & MASK) == 0u);C 형변환은 문법보다도 결과가 언제 바뀌는지가 중요합니다. 정수 나눗셈, signed/unsigned 비교, 잘림과 승격을 중심으로 다시 찾기 쉽게 정리합니다.
int total = 7;
int count = 2;
double a = (double)total / count; // 3.5
double b = (double)(total / count); // 3.0이름이 보이는 범위와 값이 살아 있는 기간은 다른 개념입니다. `local`, `static`, `extern`을 헷갈릴 때 다시 찾기 쉽게 정리합니다.
/* 현재 .c 파일에서만 이름을 쓴다. */
static int file_only = 0;
void counter(void) {
int local = 0; /* block을 벗어나면 수명이 끝난다. */
static int calls = 0;
calls += ++local; /* 프로그램이 끝날 때까지 값을 유지한다. */
}
extern int configured_limit; /* 다른 .c 파일에 있는 정의를 선언한다. */플래그와 mask에서 쓰는 비트 연산, 안전한 shift 범위, unsigned 타입 선택과 우선순위 함정을 정리합니다.
enum {
FLAG_READ = 1u << 0,
FLAG_WRITE = 1u << 1,
FLAG_EXEC = 1u << 2
};
unsigned flags = 0u;
flags |= FLAG_READ; // set
flags &= ~FLAG_WRITE; // clear
flags ^= FLAG_EXEC; // toggle
if ((flags & FLAG_READ) != 0u) {
/* FLAG_READ가 켜져 있음 */
}`sizeof`는 크기 계산 도구이지만, 배열 decay와 함수 인자 경계에서 자주 오해됩니다. 배열 길이 계산과 `malloc(sizeof *ptr)` 패턴을 중심으로 정리합니다.
int arr[] = {10, 20, 30};
size_t count = sizeof arr / sizeof arr[0];
int *p = malloc(n * sizeof *p);
size_t pointer_bytes = sizeof p; /* 배열이나 원소 수가 아니다. */`enum`은 상태 이름을 붙여 매직 넘버를 줄이고, `typedef`는 긴 타입 표기를 줄입니다. 둘을 같은 카드에서 다루되 역할은 섞지 않게 정리합니다.
typedef enum {
STATUS_OK,
STATUS_WARN,
STATUS_ERROR
} Status;
typedef struct {
int x;
int y;
} Point;
enum { FLAG_READ = 1u << 0, FLAG_WRITE = 1u << 1 };
unsigned permissions = FLAG_READ | FLAG_WRITE;`volatile`과 `restrict`는 둘 다 최적화와 관련 있지만 완전히 다른 문제를 해결합니다. 하드웨어/시그널 쪽의 `volatile`, aliasing 약속인 `restrict`를 분리해서 정리합니다.
volatile uint32_t *status = (volatile uint32_t *)0x40000000;
void copy_fast(int * restrict dst, const int * restrict src, int n);`if/else if/else`와 삼항 연산자를 언제 고를지, 조건 순서와 분기 밀도가 어떻게 가독성을 바꾸는지 정리합니다.
if (ready) {
start(); /* 조건이 참일 때만 */
}
if (score >= 60) {
pass(); /* 둘 중 한 경로 */
} else {
fail();
}
if (score >= 90) {
grade = 'A'; /* 좁은 조건을 먼저 */
} else if (score >= 80) {
grade = 'B';
} else {
grade = 'F';
}
const char *result = ready ? "start" : "wait";for, while, do-while의 선택 기준과 break, continue, 경계와 종료 조건을 읽는 법을 정리합니다.
#include <stddef.h>
#include <stdio.h>
/* 횟수·인덱스가 보이면 for */
int scores[] = {90, 85, 100};
size_t len = sizeof(scores) / sizeof(scores[0]);
int sum = 0;
for (size_t i = 0; i < len; i++) {
sum += scores[i];
}
/* 종료 조건을 먼저 검사하면 while */
int ch;
while ((ch = getchar()) != '\n' && ch != EOF) {
/* 입력을 한 문자씩 처리 */
}
/* 본문을 한 번 실행한 뒤 검사하면 do-while */
int attempts = 0;
do {
attempts++;
} while (attempts < 3);`switch`는 값 기반 분기에 적합하지만 `break` 하나만 빠져도 흐름이 무너집니다. fallthrough를 의도적으로 쓰는 경우와 실수하는 경우를 분리해서 정리합니다.
switch (command) {
case CMD_START:
start_engine();
break;
case CMD_STOP:
stop_engine();
break;
case CMD_HELP:
case CMD_VERSION:
print_usage(); /* 같은 동작은 label을 연속으로 둔다. */
break;
default:
fprintf(stderr, "unknown command\n");
break;
}C에서 `goto`는 아무 데나 쓰는 도구가 아니라, 여러 자원을 획득한 함수의 정리 경로를 한곳에 모으는 용도로 가장 실전적입니다. cleanup 레이블 패턴을 중심으로 정리합니다.
#include <stdio.h>
#include <stdlib.h>
int read_exact(const char *path, size_t size) {
FILE *fp = NULL;
unsigned char *buffer = NULL;
int ok = 0;
if (path == NULL) return 0;
fp = fopen(path, "rb");
if (fp == NULL) goto cleanup;
if (size != 0) {
buffer = malloc(size);
if (buffer == NULL) goto cleanup;
if (fread(buffer, 1, size, fp) != size) goto cleanup;
}
ok = 1;
cleanup:
free(buffer); /* 획득의 역순으로 정리한다. */
if (fp != NULL && fclose(fp) != 0) ok = 0;
return ok;
}함수 원형, 매개변수 없음 형태, 값 전달과 포인터 전달, 반환값과 출력 매개변수의 기본 선택 기준을 정리합니다.
#include <stdio.h>
/* 선언(prototype): 다른 위치에서 호출하기 전에 시그니처를 알린다. */
int max_of(int a, int b);
void print_ready(void);
int divide(int a, int b, int *q);
/* 정의: 선언과 같은 시그니처로 본문을 제공한다. */
int max_of(int a, int b) {
return (a > b) ? a : b;
}
void print_ready(void) {
puts("ready");
}
int divide(int a, int b, int *q) {
if (b == 0 || q == NULL) return 0;
*q = a / b;
return 1;
}
int main(void) {
int left = 10;
int right = 20;
int quotient;
int best = max_of(left, right); /* 호출 */
if (divide(left, right, "ient)) {
printf("best=%d, quotient=%d\n", best, quotient);
}
print_ready();
return 0;
}C 배열을 고정 길이 연속 메모리로 읽는 법, 같은 스코프에서만 길이를 안전하게 구하는 패턴, 함수 호출 시 배열 decay가 왜 중요한지 정리합니다.
#include <stddef.h>
#include <stdio.h>
int scores[5] = {90, 85, 100, 70, 88};
size_t len = sizeof(scores) / sizeof(scores[0]);
for (size_t i = 0; i < len; i++) {
printf("%d\n", scores[i]);
}
void print_scores(const int *arr, size_t n) {
for (size_t i = 0; i < n; i++) {
printf("%d\n", arr[i]);
}
}다차원 배열은 결국 메모리에 줄줄이 이어진 행 우선 블록입니다. 함수 인자에서 왜 열 크기를 알아야 하는지와 동적 2D 배열 선택지를 중심으로 정리합니다.
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
void clear_matrix(size_t rows, size_t cols, int matrix[rows][cols]) {
for (size_t r = 0; r < rows; r++) {
for (size_t c = 0; c < cols; c++) matrix[r][c] = 0;
}
}
int main(void) {
enum { ROWS = 2, COLS = 3 };
int matrix[ROWS][COLS] = {{1, 2, 3}, {4, 5, 6}};
clear_matrix(ROWS, COLS, matrix);
size_t rows = ROWS;
size_t cols = COLS;
if (cols != 0 && rows > SIZE_MAX / cols) return 1;
size_t count = rows * cols;
if (count > SIZE_MAX / sizeof(int)) return 1;
int *flat = malloc(count * sizeof *flat);
if (flat == NULL) return 1;
size_t r = 1;
size_t c = 2;
flat[r * cols + c] = 1; /* flat buffer의 행 우선 인덱스 */
free(flat);
return 0;
}배열은 함수 경계를 넘는 순간 길이 정보를 잃습니다. 그래서 `arr + n`이나 `(ptr, len)` 패턴이 기본이 되며, `const`는 읽기 전용 의도를 드러내는 도구로 같이 봐야 합니다.
/* 읽기 전용: arr[0]부터 arr[n - 1]까지 읽을 수 있어야 한다. */
int sum_array(const int *arr, size_t n);
/* 수정 가능: 같은 범위를 쓸 수 있어야 한다. */
void clear_array(int *arr, size_t n);
/* C99: 적어도 n개 원소를 넘긴다는 호출자 계약 */
void normalize(size_t n, double arr[static n]);재귀는 코드 모양보다 종료 조건과 호출 깊이가 핵심입니다. 언제 반복문보다 자연스럽고, 언제 스택 부담 때문에 피해야 하는지 중심으로 정리합니다.
int factorial(int n) {
if (n < 0) {
return 0; /* 이 예제의 입력 범위 밖 */
}
if (n == 0) {
return 1; /* 종료 조건 */
}
return n * factorial(n - 1); /* 더 작은 문제 */
}배열 경계 문제는 대부분 `<`와 `<=` 하나에서 시작합니다. C는 경계를 검사해 주지 않기 때문에 off-by-one이 바로 메모리 오염으로 이어질 수 있다는 점에 초점을 둡니다.
for (size_t i = 0; i < n; i++) {
arr[i] = 0;
}
for (int *p = arr; p != arr + n; p++) {
*p = 0; /* arr + n 자체는 역참조하지 않는다. */
}
char name[8];
snprintf(name, sizeof name, "%s", source); /* 마지막 한 칸은 '\0' */`qsort`와 `bsearch`는 API 암기보다 비교 함수 규약이 더 중요합니다. 정렬 기준, 오버플로우 없는 비교, 정렬 후 검색 흐름을 한 번에 정리합니다.
#include <stdlib.h>
int cmp_int(const void *a, const void *b) {
int ia = *(const int *)a;
int ib = *(const int *)b;
return (ia > ib) - (ia < ib);
}
int values[] = {42, 7, 19, 7};
size_t count = sizeof values / sizeof values[0];
qsort(values, count, sizeof values[0], cmp_int);
int key = 19;
int *found = bsearch(&key, values, count, sizeof values[0], cmp_int);함수 포인터 선언을 읽는 법, 콜백으로 동작을 주입하는 패턴, dispatch table과 `qsort` 연결까지 함수 포인터를 다시 찾는 상황 중심으로 정리합니다.
#include <stdio.h>
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int (*fp)(int, int) = add; /* 함수 하나를 가리키는 선언 */
printf("%d\n", fp(2, 3));
typedef int (*Op)(int, int); /* 같은 시그니처에 이름을 붙인다. */
Op ops[] = { add, sub };
size_t choice = 0;
if (choice < sizeof ops / sizeof ops[0] && ops[choice] != NULL) {
printf("%d\n", ops[choice](8, 3));
}포인터를 주소 저장 문법이 아니라 원본 수정과 공유를 위한 도구로 읽는 법, `&`와 `*`, NULL 체크, 잘못된 포인터가 왜 위험한지 정리합니다.
int value = 10;
int *ptr = &value;
if (ptr != NULL) {
printf("%d\n", *ptr); /* 유효한 객체를 가리킬 때만 역참조 */
*ptr = 20;
}배열이 언제 포인터처럼 동작하는지, 함수 인자에서 길이 정보가 왜 사라지는지, decay가 일어나지 않는 예외 상황을 정리합니다.
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr; /* 대부분의 식에서는 첫 원소 포인터로 decay */
size_t bytes = sizeof arr; /* 여기서는 배열 전체가 남아 있다. */
int (*whole)[5] = &arr; /* 배열 전체를 가리키는 포인터 */
printf("%d\n", p[2]);
printf("%d\n", *(p + 2));힙 할당이 왜 필요한지, `malloc`과 `free`를 소유권 관점에서 어떻게 읽어야 하는지, 누수와 use-after-free를 막는 기본 규칙을 정리합니다.
size_t n = 10;
int *arr = malloc(n * sizeof *arr);
if (arr == NULL && n != 0) {
return 1;
}
arr[0] = 42; /* 성공한 allocation만 사용 */
free(arr); /* 이 allocation의 수명을 끝낸다. */
arr = NULL;`ptr + 1`이 바이트가 아니라 원소 단위로 이동하는 이유, 배열 인덱싱과의 관계, 같은 배열 안에서만 안전하다는 제약을 정리합니다.
int data[] = {10, 20, 30, 40, 50};
int *ptr = data;
int *end = data + sizeof data / sizeof data[0];
printf("%d\n", *ptr);
printf("%d\n", *(ptr + 1));
ptr++;
ptrdiff_t distance = end - data; /* 같은 배열 안의 원소 수 차이 */`const`가 포인터 선언 어디에 붙느냐에 따라 무엇을 못 바꾸는지, 읽기 전용 API 설계에 왜 중요한지, 문자열 리터럴과 함께 어떻게 읽어야 하는지 정리합니다.
int value = 10;
const int *read_only = &value; /* *read_only는 수정하지 않는다. */
int *const fixed_address = &value; /* 포인터를 다른 주소로 바꾸지 않는다. */
const int *const fixed_view = &value; /* 주소와 대상 모두 바꾸지 않는다. */
/* read_only = &other; 는 가능하지만 *read_only = 20; 은 불가 */
*fixed_address = 20;포인터 변수 자체를 바꾸는 T **, out parameter의 실패 계약, argv와 연결 리스트에서 읽는 법을 정리합니다.
int value = 10;
int *p = &value;
int pp = &p;
*pp = NULL; /* p 자체를 바꿈 */
p = &value;
pp = 99; /* value를 바꿈 */
int *result = NULL;
if (make_value(&result)) {
/* make_value가 result의 새 소유권을 넘긴 경우 사용한다. */
free(result);
}calloc의 바이트 0 초기화, realloc의 소유권과 실패 처리, 동적 배열의 크기 변경 규칙을 정리합니다.
int *counts = calloc(count, sizeof(*counts));
if (counts == NULL && count != 0) {
/* 할당 실패 */
}
size_t new_count = count * 2;
int *grown = realloc(counts, new_count * sizeof *counts);
if (grown != NULL) {
counts = grown; /* 성공한 뒤에만 소유 포인터를 교체 */
}
free(counts); /* 크기를 0으로 만들 때는 직접 해제 */`memcpy`, `memmove`, `memset`를 언제 각각 써야 하는지, 겹치는 영역과 바이트 수 계산에서 왜 자주 깨지는지 정리합니다.
int src[] = {1, 2, 3};
int dst[3];
memcpy(dst, src, sizeof dst); /* 두 배열은 겹치지 않는다. */
char text[] = "move";
memmove(text, text + 1, strlen(text)); /* 같은 buffer에서 왼쪽으로 이동 */
int values[3];
memset(values, 0, sizeof values); /* 0 byte 채움은 0 int 초기화에 쓸 수 있다. */C 메모리 버그를 증상보다 원인 패턴으로 추적하는 체크리스트, 버퍼 오버런/use-after-free/double free/누수와 ASan·Valgrind 사용 기준을 정리합니다.
// gcc -fsanitize=address -g -o prog prog.c
int *arr = malloc(5 * sizeof(int));
arr[5] = 99; // ASan이 바로 잡아내기 좋은 버그
free(arr);C 문자열을 별도 타입이 아니라 `char` 배열과 널 종료 규약으로 읽는 법, 비교/복사/입력에서 가장 흔한 함정을 정리합니다.
char name[20] = "Mina";
size_t len = strlen(name);
int same = (strcmp(name, "Mina") == 0);
char copy[20];
int written = snprintf(copy, sizeof copy, "%s", name);
if (written < 0 || (size_t)written >= sizeof copy) {
/* 인코딩 오류 또는 잘림 */
}관련 필드를 묶는 구조체, 값 복사와 얕은 복사, 포인터 필드의 소유권과 전달 방식을 정리합니다.
#include <stdio.h>
typedef struct {
char name[32];
int age;
double score;
} Student;
Student student = {"Mina", 20, 97.5};
printf("%s %d %.1f\n", student.name, student.age, student.score);구조체 포인터로 원본을 수정하는 흐름, `->`가 `(*ptr).field`의 축약이라는 점, 동적 할당 구조체에서 무엇을 조심해야 하는지 정리합니다.
typedef struct {
char name[20];
int score;
} Student;
Student s = {"Kim", 90};
Student *ptr = &s;
ptr->score += 5;
s.score += 5; /* ptr->score와 같은 원본 필드 */`strncat`, `strstr`, `strchr`, `strtok`, `snprintf`, `strtol` 같은 문자열 함수들을 언제 써야 하는지와 각각의 위험 지점을 정리합니다.
char buf[64] = "Hello";
strncat(buf, ", World", sizeof(buf) - strlen(buf) - 1);
char *pos = strstr(buf, "World");
if (pos) printf("found at offset %td\n", pos - buf);`union`은 여러 멤버를 동시에 담는 구조가 아니라 같은 메모리를 여러 해석으로 공유하는 구조입니다. 태그 공용체와 메모리 공유 감각을 중심으로 정리합니다.
typedef enum { VALUE_INT, VALUE_FLOAT } ValueKind;
typedef struct {
ValueKind kind;
union {
int i;
float f;
} data;
} Value;
Value value = { .kind = VALUE_INT, .data.i = 42 };
if (value.kind == VALUE_INT) {
printf("%d\n", value.data.i);
}구조체 크기가 멤버 크기 합과 다를 수 있는 이유는 정렬과 패딩 때문입니다. 필드 순서, `offsetof`, 직렬화 위험을 중심으로 정리합니다.
struct Padded {
char a;
int b;
char c;
};`isdigit`, `isalpha`, `isspace`, `toupper`, `tolower`는 입력 검증과 문자 정규화에서 자주 쓰입니다. 특히 `unsigned char` 캐스트가 왜 필요한지 중심으로 정리합니다.
if (isdigit((unsigned char)c)) { }
if (isspace((unsigned char)c)) { }
ch = (char)tolower((unsigned char)ch);연결 리스트는 문법보다 포인터 연결, head 교체, 해제 책임이 핵심입니다. 삽입/삭제/순회/해제에서 어디가 자주 깨지는지 중심으로 정리합니다.
#include <stdlib.h>
typedef struct Node {
int val;
struct Node *next;
} Node;
int push_front(Node head, int value) {
if (head == NULL) return 0;
Node *node = malloc(sizeof *node);
if (node == NULL) return 0;
node->val = value;
node->next = *head;
*head = node; /* head 자체를 바꾼다. */
return 1;
}
void free_all(Node head) {
if (head == NULL) return;
while (*head != NULL) {
Node *next = (*head)->next;
free(*head);
*head = next;
}
}`printf`, `fprintf`, `fgets`, `getchar`를 언제 고르는지와 표준 스트림 세 가지의 역할을 빠르게 구분할 수 있게 정리합니다.
printf("count=%d\n", count);
fprintf(stderr, "error: %s\n", msg);
char line[128];
if (fgets(line, sizeof line, stdin) != NULL) {
/* 한 줄을 받은 뒤 필요하면 숫자·형식을 해석한다. */
}
int ch;
while ((ch = getchar()) != EOF) {
/* EOF와 구별하려면 char가 아니라 int로 받는다. */
}파일 I/O는 `fopen`보다도 열기 실패, 읽기 결과 확인, 텍스트와 바이너리 구분, 닫기 책임이 핵심입니다. 자주 쓰는 흐름만 한 장으로 정리합니다.
FILE *fp = fopen("notes.txt", "r");
if (fp == NULL) {
perror("fopen");
return 1;
}
char line[256];
while (fgets(line, sizeof line, fp) != NULL) {
/* 줄 하나를 정상적으로 읽은 경우만 처리 */
}
if (ferror(fp)) {
/* EOF가 아닌 읽기 오류 */
}
if (fclose(fp) != 0) {
/* buffered write의 실패가 여기서 드러날 수 있다. */
}`scanf` 뒤에 문자 입력이 꼬이는 이유, 반환값 검사와 버퍼 비우기 패턴, `fgets + sscanf`가 더 나은 상황을 한 장에 모았습니다.
if (scanf("%d", &n) != 1) {
/* 실패 처리 */
}
if (scanf(" %c", &ch) != 1) {
/* 앞 공백이 남은 개행을 건너뛴다. */
}
char word[32];
if (scanf("%31s", word) != 1) {
/* buffer보다 하나 작은 field width */
}`argc`와 `argv`는 어렵지 않지만, 숫자 변환과 옵션 파싱에서 금방 허술해집니다. `strtol`, 플래그 처리, usage 출력 기준을 중심으로 정리합니다.
int main(int argc, char *argv[]) {
if (argc < 2) {
fprintf(stderr, "usage: %s <input>\n", argv[0]);
return 1;
}
errno = 0;
char *end;
long repeat = strtol(argv[1], &end, 10);
if (errno == ERANGE || end == argv[1] || *end != '\0') {
fprintf(stderr, "invalid repeat count: %s\n", argv[1]);
return 1;
}
return 0;
}`assert`는 개발 중 전제 확인용이고, `errno`는 실패 원인을 꺼내는 도구입니다. 둘 다 오류 처리처럼 보이지만 쓰는 시점이 다르다는 점에 초점을 맞춥니다.
assert(ptr != NULL);
FILE *fp = fopen(path, "r");
if (fp == NULL) {
perror("fopen"); /* errno를 바꿀 다른 호출보다 먼저 기록 */
}
errno = 0;
char *end;
long value = strtol(text, &end, 10);
if (errno == ERANGE || end == text || *end != '\0') {
/* 범위·형식 오류 */
}현재 시각, 경과 시간, CPU 시간, 날짜 포맷을 각각 어떤 API로 보는지 나눠서 정리합니다. `time`, `difftime`, `clock`, `strftime`의 역할이 섞이지 않게 보는 카드입니다.
time_t now = time(NULL);
double elapsed = difftime(end, start);전처리기는 C 문법을 이해하지 않고 텍스트를 바꿉니다. 그래서 `#include`, `#define`, 조건부 컴파일을 쓸 때도 타입 안정성보다 치환 규칙을 먼저 봐야 합니다.
#include <stdio.h>
#define MAX_BUFFER 256
#ifdef DEBUG
#define LOG(msg) fprintf(stderr, "[DBG] %s\n", (msg))
#else
#define LOG(msg) ((void)0)
#endif
static inline int max_int(int a, int b) {
return a > b ? a : b; /* 타입 검사와 인자 한 번 평가 */
}헤더는 인터페이스를 공유하는 곳이고, include guard는 같은 선언이 여러 번 들어오는 것을 막는 장치입니다. 무엇을 헤더에 두고 무엇을 `.c`에 둘지 빠르게 판단하게 정리합니다.
/* state.h */
#ifndef STATE_H
#define STATE_H
extern int g_count;
void reset_count(void);
#endifC 빌드는 컴파일과 링크가 분리됩니다. 그래서 선언과 정의가 다른 파일에 있어도 컴파일은 되지만, 링크에서 `undefined reference`나 `multiple definition`이 터질 수 있습니다.
cc -Wall -Wextra -c main.c
cc -Wall -Wextra -c math_utils.c
cc main.o math_utils.o -o app함수형 매크로가 위험한 이유는 결국 텍스트 치환과 중복 평가입니다. 어떤 경우에 매크로를 버리고 `static inline`으로 옮겨야 하는지 판단 기준을 정리합니다.
#define MAX(a, b) ((a) > (b) ? (a) : (b))
/* MAX(i++, j++) 는 위험 */
static inline int max_int(int a, int b) {
return a > b ? a : b;
}
#define LOG_ERROR(msg) do { \
fprintf(stderr, "error: %s\n", (msg)); \
} while (0)static inline의 헤더 유틸리티 패턴, 매크로와의 차이, inline 최적화와 linkage 규칙을 정리합니다.
/* math_utils.h */
static inline int clamp_zero(int value) {
return value < 0 ? 0 : value;
}