C 言語仕様ガイド

char      c = 'A';     // 1バイト（文字 or 小整数）
short     s = 32767;   // 少なくとも 16bit
int       i = -42;     // 少なくとも 16bit（多くの環境で 32bit）
long      l = 100000L; // 少なくとも 32bit
long long ll = 9LL;    // 少なくとも 64bit（C99 以降）
float     f = 3.14f;   // 32bit 単精度
double    d = 3.14159; // 64bit 倍精度
void     *p;           // 型なしポインタ

// 移植性重視なら <stdint.h>
#include <stdint.h>
int32_t  a = 0;        // 必ず 32bit 符号付き
uint8_t  b = 255;      // 必ず 8bit 符号なし

unsigned int u = 0;
u - 1;           // UINT_MAX（ラップアラウンド、合法）

int i = INT_MAX;
i + 1;           // 未定義動作！（符号付きオーバーフロー）

// 混在比較の罠
int     neg = -1;
unsigned int pos = 1;
if (neg < pos) { }  // 偽！neg が unsigned に昇格して大きな値になる

int g;            // グローバル → 0 に初期化
static int s;     // static    → 0 に初期化

void f(void) {
    int local;    // 自動変数  → 不定（ゴミ値）
    int x = 0;   // 明示的な初期化が安全

    // C99 以降：宣言は先頭以外にも書ける
    for (int i = 0; i < 10; i++) { }
}

#define MAX_BUF 256       // 型なし定数（プリプロセッサ）
const int MAX_RETRY = 3;  // 型付き定数（推奨）

// const ポインタの 2 つの意味
const int *p;   // 「const int へのポインタ」→ *p 変更不可
int * const q;  // 「int への const ポインタ」→ q 自体が変更不可
const int * const r; // 両方不可

sizeof(int)     // 4（多くの環境）
sizeof(double)  // 8
sizeof(char)    // 常に 1

int arr[10];
sizeof(arr)                    // 40（配列全体のバイト数）
sizeof(arr) / sizeof(arr[0])   // 10（要素数の常套句）

int *p = arr;
sizeof(p)       // 8（ポインタのサイズ）← 配列サイズではない！

10 / 3    // 3（整数切り捨て）
10 % 3    // 1（余り）
-7 / 2    // -3（C99: ゼロ方向切り捨て）
-7 % 2    // -1（割られる数と同符号）
10.0 / 3  // 3.333...（どちらかが浮動小数なら浮動小数演算）

unsigned int flags = 0x0A; // 0b00001010

flags & 0x03   // 0x02（AND: 共通ビット抽出）
flags | 0x05   // 0x0F（OR:  ビット追加）
flags ^ 0x0F   // 0x05（XOR: ビット反転）
~flags         // 0xFFFFFFF5（全ビット反転）
1u << 3        // 8（左シフト = 2^3 倍）
16u >> 2       // 4（右シフト = 4 で割る）

int x = 5;
if (x = 0) {       // バグ！x に 0 を代入し評価値が 0（偽）
    printf("zero\n");  // 実行されない
}

// ヨーダ記法で防ぐ（定数を左辺に）
if (0 == x) { }    // 0 = x はコンパイルエラーになるので安全

// 意図的な代入ループは括弧で明示
int c;
while ((c = getchar()) != EOF) { }

int i = 3;
int a = ++i;  // a = 4, i = 4（前置）
int b = i++;  // b = 4, i = 5（後置）

// 未定義動作の例
int x = 1;
int y = x++ + x++;  // 未定義動作！
a[i] = i++;         // 未定義動作！

// よくある罠
if (flags & MASK == 0) { }    // (flags & (MASK == 0)) と解釈される！

// 正しい書き方
if ((flags & MASK) == 0) { }  // 括弧で優先順位を明示

// 三項演算子（右結合）
int max = a > b ? a : b;

// C99 以降：<stdbool.h> で bool/true/false が使える
#include <stdbool.h>
bool flag = true;

int *p = get_ptr();
if (p) {           // p != NULL と同じ意味（慣用句）
    *p = 42;
}

if (x > 0) {
    puts("positive");
} else if (x < 0) {
    puts("negative");
} else {
    puts("zero");
}

int code = 2;
switch (code) {
    case 1:
        puts("one");
        break;
    case 2:
    case 3:              // フォールスルーで 2 と 3 を同じ処理に
        puts("two or three");
        break;
    default:
        puts("other");
        break;
}

// 意図しないフォールスルーを防ぐため break を忘れずに

// C99 以降：for 文内で変数宣言可
for (int i = 0; i < 10; i++) {
    if (i == 5) continue;  // このイテレーションをスキップ
    if (i == 8) break;     // ループを抜ける
    printf("%d ", i);
}

// while
int n = 10;
while (n > 0) { n--; }

// do-while（最低 1 回実行）
int input;
do {
    scanf("%d", &input);
} while (input < 0);  // 正の値が入力されるまで繰り返す

int process(void) {
    void *buf1 = malloc(100);
    if (!buf1) goto err0;

    void *buf2 = malloc(200);
    if (!buf2) goto err1;

    // ... 処理 ...
    free(buf2);
    free(buf1);
    return 0;

err1: free(buf1);
err0: return -1;
}

// プロトタイプ宣言（引数名は省略可）
int add(int, int);

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

// 引数なしの関数は (void) と明示する
void greet(void) {
    puts("Hello");
}

// 値渡し：呼び出し元は変化しない
void double_val(int x) { x *= 2; }

// ポインタ渡し：呼び出し元の変数を変更できる
void double_ptr(int *x) { *x *= 2; }

int n = 5;
double_val(n);   // n はまだ 5
double_ptr(&n);  // n は 10 になる

// 複数の値を返すにもポインタ渡しを使う
void min_max(int *arr, int len, int *min, int *max);

// このファイル内でのみ使える関数
static int helper(int x) { return x * 2; }

// インライン展開のヒント（C99）
static inline int square(int x) { return x * x; }

// 変数に対する static：関数を抜けても値を保持
void counter(void) {
    static int count = 0;  // 初回のみ 0 に初期化
    count++;
    printf("%d\n", count);
}

#include <stdarg.h>
#include <stdio.h>

// count 個の int の合計を返す
int sum(int count, ...) {
    va_list ap;
    va_start(ap, count);  // count の後ろから可変引数が始まる
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += va_arg(ap, int);
    }
    va_end(ap);
    return total;
}

sum(3, 10, 20, 30); // → 60

// 階乗（再帰）
long long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// 深い再帰が必要な場合はループに書き直す
long long factorial_iter(int n) {
    long long result = 1;
    for (int i = 2; i <= n; i++) result *= i;
    return result;
}

int a[5];                    // 未初期化（ゴミ値）
int b[5] = {1, 2, 3, 4, 5};
int c[5] = {0};              // 全要素を 0 に初期化
int d[] = {10, 20, 30};      // サイズ省略（3 と推論）

// 指定初期化子（C99）
int e[5] = {[0]=1, [4]=5};   // 中間はゼロ

printf("%d\n", b[0]);        // 1
printf("%zu\n", sizeof(b) / sizeof(b[0]));  // 5

int arr[5] = {0, 1, 2, 3, 4};
arr[5] = 99;   // 未定義動作！インデックスは 0〜4 のみ有効
arr[-1] = 0;   // 未定義動作！

// 安全に使うには常に範囲チェック
int idx = get_index();
if (idx >= 0 && idx < 5) {
    arr[idx] = 99;
}

char s1[] = "hello";    // {'h','e','l','l','o','\0'} と等価（6要素）
char s2[6] = "hello";   // 同上
char s3[5] = "hello";   // '\0' が入らない → 文字列として危険！

const char *p = "hello"; // 文字列リテラルへのポインタ（読み取り専用）

strlen(s1);  // 5（NUL を含まない長さ）
sizeof(s1);  // 6（NUL を含むバイト数）

#include <string.h>
char dst[20];
char src[] = "hello";

strcpy(dst, src);            // コピー（dst が小さいと溢れる）
strncpy(dst, src, sizeof(dst) - 1);  // 長さ制限付き
dst[sizeof(dst) - 1] = '\0'; // NUL 終端を保証（strncpy はしない場合がある）

strcat(dst, " world");       // 末尾に連結
strlen(dst);                 // 文字数（NUL 除く）
strcmp("abc", "abd");        // 負値（"abc" < "abd"）
strncmp("abc", "abX", 2);    // 0（最初の 2 文字が等しい）

int mat[3][4];           // 3行4列（12要素が連続配置）
mat[1][2] = 42;          // 行 1、列 2

// 関数に渡す場合、最初の次元は省略可だが後続は必須
void print_matrix(int m[][4], int rows);

// C99 VLA（可変長配列）
int rows = 3, cols = 4;
int vla[rows][cols];     // スタック上に確保（サイズ大きいと危険）

int x = 42;
int *p = &x;  // p に x のアドレスを格納

printf("%p\n", (void *)p);  // アドレスを表示
printf("%d\n", *p);         // 42（逆参照）

*p = 100;    // x の値を 100 に変更
printf("%d\n", x);  // 100

// ポインタ自体のアドレス（ポインタへのポインタ）
int **pp = &p;

int *p = NULL;
if (p != NULL) { *p = 1; }  // NULL チェック必須

// ダングリングポインタ（関数からローカル変数のアドレスを返す）
int *bad(void) {
    int local = 42;
    return &local;   // 危険！local はスコープを抜けると無効
}

// free 後もポインタは古いアドレスを保持（ダングリング）
int *q = malloc(sizeof(int));
free(q);
q = NULL;   // free 後は必ず NULL を代入する慣習

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;  // arr は &arr[0] に等しい

*(p + 1)      // 20（p から 1 要素分進んだ先）
p[2]          // 30（*(p+2) と同じ）

// ポインタ走査
for (int *it = arr; it < arr + 5; it++) {
    printf("%d ", *it);
}

// ポインタの差（ptrdiff_t 型）
int *end = arr + 5;
ptrdiff_t len = end - arr;  // 5

int arr[5] = {1,2,3,4,5};
int *p = arr;        // arr → &arr[0] に decay

sizeof(arr)  // 20（配列全体）← decay しない
sizeof(p)    // 8（ポインタサイズ）

&arr         // int (*)[5]（配列全体へのポインタ）
&arr[0]      // int *（先頭要素へのポインタ）

// 関数引数では必ず decay する
void f(int a[5]) { }   // int *a と同じ宣言

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

// 関数ポインタの宣言：int (*名前)(int, int)
int (*op)(int, int) = add;
op(3, 4);   // 7

// typedef で読みやすく
typedef int (*BinOp)(int, int);
BinOp ops[] = {add, mul};
ops[1](3, 4);  // 12

// qsort のコールバック
#include <stdlib.h>
int cmp(const void *a, const void *b) {
    return *(int*)a - *(int*)b;
}
int arr[5] = {3,1,4,1,5};
qsort(arr, 5, sizeof(int), cmp);

// 宣言と typedef を同時に
typedef struct {
    char name[64];
    int  age;
    double score;
} Person;

// 初期化
Person p1 = {"Alice", 30, 98.5};
Person p2 = {.name = "Bob", .age = 25};  // 指定初期化子（C99）

// メンバアクセス
printf("%s\n", p1.name);   // 値へのアクセス

// ポインタ経由
Person *ptr = &p1;
printf("%d\n", ptr->age);  // (*ptr).age と同じ

typedef struct {
    char *name;   // ポインタメンバ
    int age;
} Node;

Node a = {.name = malloc(64), .age = 20};
strcpy(a.name, "Alice");

Node b = a;     // 浅いコピー：b.name は a.name と同じアドレス
b.age = 25;     // OK（int はコピーされている）
b.name[0] = 'X';// a.name も "Xlice" に変わってしまう！

free(a.name);
// free(b.name); ← 二重 free になる！

// パディングあり：char 後に 3 バイトのパディング
struct Padded { char c; int i; };   // sizeof → 8 (多くの環境)

// パディング削減：大きい型を先に
struct Packed  { int i; char c; };  // sizeof → 8（末尾に 3 バイト）

// メンバ順を整理すると小さくなる場合
struct Optimal { double d; int i; char c; };  // sizeof → 16

#include <stddef.h>
offsetof(struct Padded, i);  // i の先頭からのオフセット（通常 4）

typedef union {
    int   i;
    float f;
    char  bytes[4];
} Variant;

Variant v;
v.i = 0x3f800000;
printf("%f\n", v.f);  // IEEE 754 で 1.0 と解釈される

// タグ付き共用体（どのメンバが有効かを struct で管理）
typedef struct {
    enum { TYPE_INT, TYPE_FLOAT } tag;
    union { int i; float f; } val;
} TaggedValue;

typedef enum {
    COLOR_RED   = 0,
    COLOR_GREEN = 1,
    COLOR_BLUE  = 2
} Color;

Color c = COLOR_RED;

// 列挙子はグローバルに漏れる（名前衝突に注意）
// RED だと他の定義と衝突しやすいので COLOR_ プレフィックスを使う慣習

// int との代入が通ってしまう（型チェックが緩い）
int n = COLOR_GREEN;  // 警告なしでコンパイルされる

#include <stdlib.h>

// malloc：未初期化メモリを確保
int *p = malloc(10 * sizeof(int));
if (!p) { /* 失敗処理 */ }

// calloc：ゼロ初期化（個数 × サイズ）
int *q = calloc(10, sizeof(int));

// realloc：サイズ変更（失敗時は NULL、元のポインタは無効化されない）
int *r = realloc(p, 20 * sizeof(int));
if (!r) { free(p); /* 元のメモリを解放 */ }
else    { p = r; }

free(p);
p = NULL;  // 解放後は NULL を代入

// メモリリーク例
void leak(void) {
    int *p = malloc(100);
    return;  // free を忘れた → リーク
}

// 二重 free 例
int *p = malloc(4);
free(p);
free(p);   // 未定義動作！ヒープ破壊

// 安全パターン：free 後に NULL
free(p);
p = NULL;
free(p);   // NULL の free は安全（何もしない）

// 検出ツール
// valgrind --leak-check=full ./program
// gcc -fsanitize=address,leak ./program

// スタック：関数終了時に自動解放、高速
void f(void) {
    int arr[1000];       // スタック上（~4KB）
    char buf[1024*1024]; // 1MB → スタックオーバーフローの危険
}

// ヒープ：明示的に malloc/free が必要、低速だが大きく確保可能
void g(void) {
    char *buf = malloc(1024 * 1024);  // 1MB ヒープに確保
    // ... 使う ...
    free(buf);
}

// static/グローバル：プログラム全期間で有効
static char persistent[4096];

// 安全 free マクロ
#define SAFE_FREE(p) do { free(p); (p) = NULL; } while (0)

int *buf = malloc(64);
// ... 処理 ...
SAFE_FREE(buf);   // free して NULL に
SAFE_FREE(buf);   // 2回目は NULL の free（安全）

// do { } while(0) は複文マクロの標準イディオム
// if 文のぶら下がりを防ぐ

#include <stdio.h>

FILE *fp = fopen("data.txt", "r");  // "r"=読み取り, "w"=書き込み, "a"=追記
if (!fp) {
    perror("fopen");   // エラーメッセージを stderr に出力
    return -1;
}

// ファイル処理...

if (fclose(fp) != 0) {
    perror("fclose");
}

// モード一覧
// "r"  読み取り専用      "rb" バイナリ読み取り
// "w"  書き込み（上書き） "wb" バイナリ書き込み
// "a"  追記              "r+" 読み書き両用

char line[256];

// 行読み込み（改行 '\n' も含む）
while (fgets(line, sizeof(line), fp) != NULL) {
    printf("%s", line);
}

// テキスト書き込み
fprintf(fp, "Name: %s, Age: %d\n", "Alice", 30);
fputs("Hello\n", fp);  // 文字列書き込み

// 書式読み込み（scanf のファイル版）
int n;
fscanf(fp, "%d", &n);

typedef struct { int x, y; } Point;
Point pts[3] = {{1,2},{3,4},{5,6}};

// バイナリ書き込み
FILE *fp = fopen("pts.bin", "wb");
size_t written = fwrite(pts, sizeof(Point), 3, fp);  // 3要素書き込み
fclose(fp);

// バイナリ読み込み
Point in_pts[3];
fp = fopen("pts.bin", "rb");
size_t read = fread(in_pts, sizeof(Point), 3, fp);
fclose(fp);

FILE *fp = fopen("data.bin", "rb");

// ファイルサイズを取得する常套句
fseek(fp, 0, SEEK_END);   // 末尾へ移動
long size = ftell(fp);     // 現在位置 = ファイルサイズ
rewind(fp);                // 先頭に戻す（= fseek(fp, 0, SEEK_SET)）

// 特定位置へジャンプ
fseek(fp, 100, SEEK_SET);  // 先頭から 100 バイト目
fseek(fp, -4, SEEK_CUR);   // 現在位置から 4 バイト戻る

#define PI 3.14159265358979
#define SQ(x)    ((x) * (x))   // 全体と引数を括弧で囲む
#define MAX(a,b) ((a) > (b) ? (a) : (b))

int r = 5;
double area = PI * SQ(r);    // OK

int i = 3;
int m = MAX(i++, 2);  // (i++ > 2 ? i++ : 2) → i が 2 回インクリメントされる！

#undef PI   // マクロの取り消し

#ifdef _WIN32
    #define PATH_SEP '\\'
#else
    #define PATH_SEP '/'
#endif

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    // C99 以降のコード
#endif

// デバッグ出力
#ifdef DEBUG
    #define LOG(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)
#else
    #define LOG(fmt, ...) /* 何もしない */
#endif

// mylib.h — 古典的インクルードガード（C 標準）
#ifndef MYLIB_H
#define MYLIB_H

// ヘッダ内容

#endif /* MYLIB_H */

// または #pragma once（非標準だが主要コンパイラで使用可）
#pragma once

// ヘッダ内容

// # 文字列化：変数名と値を一緒に表示
#define SHOW(x) printf(#x " = %d\n", (x))
int answer = 42;
SHOW(answer);  // "answer = 42" と出力

// ## トークン結合：識別子を組み立て
#define MAKE_VAR(name) int var_##name
MAKE_VAR(x);   // int var_x; に展開される

// printf フォーマット指定子
printf("%d\n",   42);          // int
printf("%u\n",   42u);         // unsigned int
printf("%ld\n",  42L);         // long
printf("%lld\n", 42LL);        // long long
printf("%f\n",   3.14);        // double（float も double に昇格）
printf("%s\n",   "hello");     // 文字列
printf("%p\n",   (void*)ptr);  // ポインタ（キャストが必要）
printf("%zu\n",  sizeof(int)); // size_t

// scanf：必ずアドレスを渡す
int n;
char buf[64];
scanf("%d", &n);
scanf("%63s", buf);  // サイズ制限 63（NUL 分を引く）

#include <stdlib.h>

// 文字列 → 数値（エラー検出できない古い関数）
int n = atoi("123");

// エラー検出可能な変換（推奨）
char *end;
long l = strtol("123abc", &end, 10);  // end は変換できなかった先頭を指す
if (*end != '\0') { /* 変換失敗 */ }

// プロセス終了
exit(0);         // 正常終了（atexit 登録関数を実行）
abort();         // 異常終了（SIGABRT を発生）

// ソート・二分探索
int arr[5] = {3,1,4,1,5};
qsort(arr, 5, sizeof(int), compare_func);
int *found = bsearch(&key, arr, 5, sizeof(int), compare_func);

#include <math.h>
// コンパイル: gcc prog.c -lm

sqrt(9.0)        // 3.0
pow(2.0, 10.0)   // 1024.0
fabs(-3.5)       // 3.5（絶対値）
ceil(1.2)        // 2.0（切り上げ）
floor(1.8)       // 1.0（切り捨て）
round(1.5)       // 2.0（四捨五入）
log(M_E)         // 1.0（自然対数）
log2(8.0)        // 3.0
sin(M_PI / 2.0)  // 1.0（引数はラジアン）

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

// 現在時刻
time_t now = time(NULL);
printf("%s", ctime(&now));  // 人間可読な文字列

// 経過時間計測
clock_t start = clock();
// ... 処理 ...
double sec = (double)(clock() - start) / CLOCKS_PER_SEC;

// 乱数（シードを設定して使う）
srand((unsigned)time(NULL));
int r = rand() % 100;       // 0〜99 の乱数

// 1. 前処理：#include / #define を展開（.i ファイル）
gcc -E main.c -o main.i

// 2. コンパイル：C → アセンブリ（.s ファイル）
gcc -S main.i -o main.s

// 3. アセンブル：アセンブリ → オブジェクト（.o ファイル）
gcc -c main.c -o main.o

// 4. リンク：複数の .o + ライブラリ → 実行可能ファイル
gcc main.o util.o -o program -lm

// 一括ビルド（最終的にこれで OK）
gcc main.c util.c -o program -lm

// 開発時の推奨設定
gcc -Wall -Wextra -g -std=c17 main.c -o program

// -Wall    : 一般的な警告を有効化
// -Wextra  : 追加の警告
// -g       : デバッグシンボル（GDB 等で使用）
// -std=c17 : C17 準拠モード
// -O0      : 最適化なし（デフォルト）
// -O2      : 一般的な最適化
// -O3      : 積極的最適化
// -Os      : コードサイズ最小化（組み込み向け）

// サニタイザー（デバッグに有効）
gcc -fsanitize=address,undefined main.c -o program

// config.c
int g_count = 0;           // 外部リンケージ（他ファイルから参照可）
static int s_private = 1;  // 内部リンケージ（このファイルのみ）

// config.h
extern int g_count;   // 他ファイルへの宣言（定義は config.c）

// main.c
#include "config.h"
g_count++;  // OK、config.c の変数を参照

// Makefile
CC      = gcc
CFLAGS  = -Wall -Wextra -g -std=c17
LDFLAGS = -lm

TARGET  = program
SRCS    = main.c util.c
OBJS    = $(SRCS:.c=.o)

$(TARGET): $(OBJS)
	$(CC) $(OBJS) -o $@ $(LDFLAGS)

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

clean:
	rm -f $(OBJS) $(TARGET)

.PHONY: clean

// よくある UB パターン
int x = INT_MAX;
x + 1;                 // 符号付き整数オーバーフロー
int arr[3];
arr[3] = 0;            // 境界外アクセス
int *p = NULL;
*p = 1;                // NULL 逆参照
char *s = "hello";
s[0] = 'H';            // 文字列リテラルへの書き込み
int n;
printf("%d", n);       // 未初期化変数の読み取り

#include <stdint.h>

// エンディアン検出
int is_little_endian(void) {
    uint16_t n = 1;
    return *(uint8_t *)&n == 1;
}

// ネットワークバイトオーダー変換（<arpa/inet.h> / <winsock2.h>）
// htonl: host → network (32bit)
// ntohl: network → host (32bit)
#include <arpa/inet.h>
uint32_t net = htonl(0x12345678);

// 移植性のある整数読み書き（バイト単位で処理）
uint32_t read_le32(const uint8_t *p) {
    return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
}

#include <stddef.h>

// C11 のアライメント指定
#include <stdalign.h>
alignas(16) float vec[4];  // 16 バイト境界にアラインされた配列

// GCC 拡張：構造体のパディングを強制的に除去（バイナリ互換性のため）
struct __attribute__((packed)) NetworkHeader {
    uint8_t  version;
    uint16_t length;   // パディングなし（アライメント違反の可能性）
    uint32_t checksum;
};

// アライメント確認
_Alignof(double);  // 通常 8（C11）

// for 文内の変数宣言
for (int i = 0; i < 10; i++) { }

// bool 型（<stdbool.h>）
#include <stdbool.h>
bool flag = true;

// 可変長配列 VLA（スタック上で実行時サイズの配列）
int n = 10;
int vla[n];    // C99 以降。C11 でオプション化（VLA が不要な場合も）

// 指定初期化子
int arr[5] = {[2]=20, [4]=40};

// 複合リテラル（その場で構造体や配列を生成）
int *p = (int[]){1, 2, 3, 4};
typedef struct { int x, y; } Point;
Point pt = (Point){.x=3, .y=4};

// _Generic：型に応じて式を選択（型安全な汎用関数マクロ）
#define abs_val(x) _Generic((x), \
    int:    abs(x),              \
    long:   labs(x),             \
    double: fabs(x),             \
    default: abs(x))

// _Static_assert：コンパイル時アサート
_Static_assert(sizeof(int) == 4, "int must be 4 bytes");

// _Atomic：アトミック操作（<stdatomic.h>）
#include <stdatomic.h>
atomic_int counter = 0;
atomic_fetch_add(&counter, 1);  // スレッドセーフなインクリメント

// noreturn 属性（<stdnoreturn.h>）
#include <stdnoreturn.h>
_Noreturn void fatal(const char *msg) {
    fputs(msg, stderr);
    exit(1);
}

// typeof：型を取り出す（GCC 拡張が標準化）
int x = 5;
typeof(x) y = 10;  // int y = 10;

// nullptr：NULL ポインタ定数（型安全）
int *p = nullptr;  // NULL より型安全

// auto：型推論（初期化式から型を推論）
auto n = 42;       // int n = 42;

// #embed：バイナリファイルのインライン埋め込み
const unsigned char icon[] = {
    #embed "icon.png"
};

// 属性構文の統一（[[nodiscard]] 等が C でも使える）
[[nodiscard]] int compute(void);

// 1. 固定幅型を積極的に使う
#include <stdint.h>
uint32_t flags;  // int より意図が明確

// 2. const を積極的に付ける
const char *process(const char *input, size_t len);

// 3. サイズは size_t（符号なし）で扱う
size_t count = sizeof(arr) / sizeof(arr[0]);

// 4. 戻り値は必ず確認する
if (fclose(fp) != 0) { perror("fclose"); }

// 5. コンパイル時チェックの活用
_Static_assert(sizeof(off_t) >= 8, "Large file support required");

// 6. ツール活用
// clang-format でコード整形
// clang-tidy で静的解析
// valgrind / ASan でメモリエラー検出