🛠️ C/C++ 코딩 표준 레퍼런스C/C++ Coding Standards Reference

#include <stdio.h>
#include <stdint.h>
static int read_byte(void){ return 200; }
int main(void){
    uint32_t flags = 0xFFFFFFFFu;        /* 폭이 고정된 타입 + 명시 상수 */
    unsigned char c = (unsigned char)read_byte();  /* 부호 명시 → 항상 0..255 */
    if (c > 127u) {                      /* 의도대로 동작 */
        printf("high bit set\n");
    }
    printf("flags=%u\n", flags);
    return 0;
}

#include <stdio.h>
/* 빌드에서 제외할 코드는 삭제하거나, 남길 경우 항상 컴파일 가능한 상태로 유지 */
static int legacy_calc(void){
    return 0;   /* 유지한다면 유효하게 — 또는 버전관리 이력으로만 보존 */
}
int main(void){
    printf("build ok: %d\n", legacy_calc());
    return 0;
}

#include <stdio.h>
/* REQ-LOG-014: 운영 진단 로그를 파일에 기록한다 (요구사항 추적 ID 명시) */
static void write_diag_log(const char *msg){
    /* 요구사항에 정의된 기능만, 정의된 방식으로 구현 */
    printf("[DIAG] %s\n", msg);
}
int main(void){
    write_diag_log("system started");
    return 0;
}

#include <stdio.h>
#include <stddef.h>
/* 연산 전에 분모·포인터·개수의 유효성을 확인하고 실패를 신호로 돌려준다 */
static int average(const int *a, int n, int *ok){
    if (a == NULL || n <= 0) { *ok = 0; return 0; }
    int sum = 0;
    for (int i = 0; i < n; i++) { sum += a[i]; }
    *ok = 1;
    return sum / n;
}
int main(void){
    int data[3] = {10, 20, 30};
    int ok;
    int r = average(data, 3, &ok);
    if (ok) printf("%d\n", r);
    (void)average(data, 0, &ok);
    if (!ok) printf("rejected empty input\n");
    return 0;
}

/*
 * [ASM 사용 근거] 타깃 MCU에서 1사이클 지연이 필요하며 C로는
 *   컴파일러 최적화로 제거될 수 있어 NOP 명령을 직접 사용한다.
 * [C-ASM 인터페이스] 입력/출력/clobber 없음. ARMv7-M nop 1개.
 */
void delay_cycles(void) {
    __asm__ volatile("nop");
}

#include <stdio.h>
static void do_work(void){ /* ... */ }
/* 어셈블리는 명명된 인라인 함수/매크로로 캡슐화해 한 곳에 격리 */
static inline void cpu_nop(void){ __asm__ __volatile__("nop"); }
void busy_delay(void){
    int i = 100;
    cpu_nop();
    while (i-- > 0) { do_work(); cpu_nop(); }   /* C 로직은 어셈블리에서 분리됨 */
}
int main(void){ busy_delay(); printf("done\n"); return 0; }

#include <stdio.h>
typedef struct { int v; } Data;
static void validate(Data *d){ (void)d; }
static void notify(Data *d){ (void)d; }
#define FEATURE_TRANSFORM 0   /* 빌드 구성으로 의도를 명시 */
void process(Data *d){
    validate(d);
#if FEATURE_TRANSFORM
    transform(d);
    commit(d);
#endif
    notify(d);
}
int main(void){ Data d = {1}; process(&d); printf("ok\n"); return 0; }

int32_t id9_m;       /* Compliant     */

/* Compliant     - int used to define specific-length type           */
/* Compliant     - further abstraction does not need specific length */

#include <stdio.h>
int main(void){
    FILE *f = fopen("/etc/hostname", "r");
    if (f == NULL) {                 /* 실패를 즉시 검사하고 분기 */
        return 1;
    }
    char buf[64];
    if (fgets(buf, sizeof buf, f) != NULL) {
        printf("%s", buf);
    }
    fclose(f);
    return 0;
}

/* sensor.h — 불완전 타입으로 구현을 숨긴다(opaque type) */
typedef struct Sensor Sensor;        /* 정의는 sensor.c 안에만 존재 */
Sensor *sensor_create(void);
void    sensor_update(Sensor *s);
int32_t sensor_value(const Sensor *s);  /* 접근은 함수로만 */

static uint16_t x = DIV2 ( 10 );   /* Compliant - call not permitted */

/* sensor.h — #ifndef/#define 가드로 1회만 처리 */
#ifndef SENSOR_H
#define SENSOR_H

typedef struct { int id; int raw; } Sensor;
int sensor_init(Sensor *s);

#endif /* SENSOR_H */
/* 또는 컴파일러가 지원하면 파일 첫 줄에 #pragma once */

#include <stdio.h>
#include <math.h>
static int rms(double x, double v, double *out){
    if (x < 0.0 || v <= 0.0) { return -1; }   /* 정의역(domain) 사전 검사 */
    *out = sqrt(x) + log(v);
    return 0;
}
int main(void){
    double out;
    if (rms(4.0, 1.0, &out) == 0) printf("%f\n", out);
    if (rms(-1.0, 0.0, &out) != 0) printf("rejected invalid domain\n");
    return 0;
}

#include <string.h>
#include <stdio.h>
#define MAX_LEN 256
static void handle(const char *src, size_t len){
    char buf[MAX_LEN];          /* 정적/자동 저장기간 — 결정적 메모리 */
    if (len > sizeof buf) { return; }   /* 용량 검사 */
    memcpy(buf, src, len);
    printf("%.*s\n", (int)len, buf);
}
int main(void){ handle("payload", 7); return 0; }

extern void bar(void);   /* 사용 전 프로토타입 선언 */
int foo(void) {
    bar();
    return 0;            /* 표준 구문·제약 준수 */
}

/* 표준 C 기능만 사용 */
static int imax(int a, int b) { return a > b ? a : b; }
int arr[4] = { 1, 1, 1, 1 };

#include <stdio.h>
int main(void){
    int i = 5;
    int next = i + 1;          /* 부작용을 분리해 평가 순서를 명확히 */
    i = i + next;
    int a[3] = {0};
    int k = 0;
    a[k] = k;                  /* 인덱스와 대입을 분리 */
    k++;
    printf("%d %d (k=%d)\n", i, a[0], k);
    return 0;
}

#include <stdio.h>
static int scale(int x){
    printf("scaling %d\n", x);   /* 의도한 순서로 배치 */
    return x * 2;
}
int main(void){ printf("%d\n", scale(21)); return 0; }

/* Compliant - there are no operations in this function */

#include <stdio.h>
typedef int status_t;            /* 실제로 쓰이는 타입만 유지 */
static status_t run(void){ return 0; }
int main(void){ printf("%d\n", run()); return 0; }

typedef struct                             /* Compliant     */

#include <stdio.h>
static int on_event(int code, void *ctx){
    (void)ctx;          /* 의도적 미사용임을 명시 — 검토자에게 신호 */
    return code * 2;
}
int main(void){ printf("%d\n", on_event(21, NULL)); return 0; }

/* 이전 구현 - 임시 메모: 중첩 표기를 풀어서 한 줄로 작성 */
x = compute();
/* 주석 시작 문자(슬래시-별표)를 주석 본문에 넣지 않는다 */

const char *s2 = "\x41" "g"; /* Compliant - terminated by end of literal */
const char *s3 = "\x41\x67"; /* Compliant - terminated by another escape */
int c2 = '\141\t';           /* Compliant - terminated by another escape */

/* '?' 중 하나를 이스케이프해 트라이그래프 형성을 막는다 */
const char *msg = "Enter date (yyyy-mm-dd?\?)";

int32_t engine_exhaust_gas_temp_scaled;          /* Compliant     */

int32_t   engine_exhaust_gas_temperature_local;       /* Compliant     */
static int32_t engine_exhaust_gas_temp_scaled;          /* Compliant     */

#include <stdio.h>
static int g_count = 0;      /* 전역은 접두사로 구분 */
static void tick(void){
    int local_count = 5;     /* 바깥 이름과 다르게 */
    local_count++;
    g_count++;               /* 의도가 명확 */
    printf("local=%d\n", local_count);
}
int main(void){ tick(); printf("global=%d\n", g_count); return 0; }

#define  engine_exhaust_gas_temp_scaled         egt_s   /* Compliant     */

#define Sum(x, y) ( ( x )  + ( y ) )
int16_t x = Sum ( 1, 2 );

/*             1234567890123456789012345678901********* Characters */
#define        low_pressure_turbine_temperature_1  lp_tb_temp_1
static int32_t low_pressure_turbine_temperature_2;

} list;                            /* Compliant - exception */

struct stag a1 = { 0,  0 };   /* Compliant - compatible with above        */
} coord;                     /* Compliant by Exception                   */

int32_t index;           /* Compliant - "index" has no linkage       */
}

unsigned int b1:2;   /* Compliant                                    */
   UINT_16      b3:2;   /* Compliant - typedef designating unsigned int */

struct Flags {
    unsigned int ready : 1;  /* 0 또는 1 을 명확히 표현 */
    unsigned int error : 1;
};

code[ 1 ] = 109;   /* Compliant     - decimal 109 */
code[ 2 ] = 100;   / * Compliant     - decimal 100 */

#include <stdio.h>
#include <stdint.h>
int main(void){
    uint16_t mask = 40000u;     /* unsigned 의도 명시 */
    uint32_t big  = 0x80000000u;
    printf("%u %u\n", mask, big);
    return 0;
}

#include <stdio.h>
int main(void){
    long big = 100000L;     /* 대문자 L — 명확 */
    long long huge = 5LL;
    printf("%ld %lld\n", big, huge);
    return 0;
}

/* Compliant - p is const-qualified; additional qualifiers are permitted */
  f2 ( "string" );       /* Compliant                                    */
  return ( "MISRA" );    /* Compliant                                    */

extern int16_t x;   /* Compliant - explicit type         */
const int16_t  y;   /* Compliant - explicit type         */

extern int16_t f ( void );                   /* Compliant                */
extern void g ( char c, const int16_t k );   /* Compliant                */

/* Compliant                                                 */
/* Compliant - prototype specifies 0 parameters              */
/* Compliant                                                 */
/* Compliant - prototype specifies 0 parameters              */
/* Compliant                                                 */

extern void f1 ( int16_t x );
extern void f2 ( int16_t y );
void f ( bool_t b )
{
  void ( *fp1 ) ( int16_t z ) = b ? f1 : f2;
}

/* Compliant                                 */
  /* Compliant - rule does not apply to objects/functions with internal

/* shared.h — 외부 객체는 단 하나의 헤더에서만 선언 */
extern int16_t g_count;
/* shared.c */
#include "shared.h"
int16_t g_count = 0;   /* 정의는 한 곳 */

/* file3.c */
int16_t j;        /* Tentative definition                    */
int16_t j = 1;    /* Compliant - external definition         */

/* util.c — 내부 링키지로 가시성을 제한 */
static int helper_state = 0;
static void helper(void) { helper_state++; }

static int helper(int x);          /* 선언 */
static int helper(int x){ return x + 1; }  /* 정의 — static 일관 적용 */
/* 내부 연결 의도가 모든 선언/정의에서 일치 */

void )
{
  int32_t i;
  for ( i = 0; i < N; ++i )
  {
  }
}

/* static inline — 각 번역 단위에서 안전하게 인라인 */
static inline int square(int x) { return x * x; }

extern int32_t array1[ 10 ];   /* Compliant     */

/* Compliant                                        */

{
  return *p;
}
The code would be compliant if the function were de fi ned with:
uint16_t g ( const uint16_t *p )

#include <string.h>
void f ( void )
{
  /* memcpy has restrict-qualified parameters */
  memcpy ( p, q, n );
}

#include <stdio.h>
static int total(const int *a, int n){
    int sum = 0;    /* 사용 전 명시적 초기화 */
    for (int i = 0; i < n; i++) { sum += a[i]; }
    return sum;
}
int main(void){ int d[3] = {1,2,3}; printf("%d\n", total(d, 3)); return 0; }

int16_t z1[ 2 ][ 2 ] = { { 0 }, [ 1 ][ 1 ] = 1 };       /* Compliant     */
                       };                               /* Compliant     */
int16_t z4[ 2 ][ 2 ] = { [ 0 ][ 1 ] = 0, { 0, 1 } };    /* Compliant     */
float32_t a[ 3 ][ 2 ] = { 0 };                          /* Compliant     */
float32_t a[ 3 ][ 2 ] = { { 0 }, { 0 }, { 0 } };        /* Compliant     */
                        };                              /* Compliant     */
} u = { 0 };                                            /* Compliant     */
   { .len = 0u }              /* Compliant - buf initialized implicitly  */
};                            /* Compliant - s[] fully initialized       */

float32_t arr[ 3 ][ 2 ] =
{
  { 0.0f, 0.0f },
  { PI / 4.0f, -PI / 4.0f },
  { 0 }   /* initializes all elements of array subobject arr[ 2 ] */
};

char h[ 10 ] = "Hello";   /* Compliant by Exception 3 */

*/
int16_t a1[ 5 ] = { -5, -4, -3, -2, -1 };

/* Compliant                                                     */

/* Compliant as K1 from anonymous

#include <stdio.h>
int main(void){
    char a = 'A';
    int code = (int)a;       /* 산술이 필요하면 명시적으로 정수형으로 변환 */
    int b = code * 2;
    printf("%d\n", b);
    return 0;
}

uint8_t u8a  = 0;               /* By exception                         */
bool_t  flag = ( bool_t ) 0;
bool_t  set  = true;            /* true is essentially Boolean          */
bool_t  get  = ( u8b > u8c );
ena  = A1;
s8a  = K1;            /* Constant value fits                            */
u8a  = 2;             /* By exception                                   */
u8a  = 2 * 24;        /* By exception                                   */
cha += 1;             /* cha = cha + 1 assigns character to character   */
pu8a = pu8b;                  /* Same essential type                    */
u8a  = u8b + u8c + u8d;       /* Same essential type                    */
u8a  = ( uint8_t ) s8a;       /* Cast gives same essential type         */

u32a = u16a;                  /* Assignment to a wider essential type   */
u32a = 2U + 125U;             /* Assignment to a wider essential type   */
use_uint16 ( u8a  );          /* Assignment to a wider essential type   */
use_uint16 ( u8a + u16b );    /* Assignment to same essential type      */

#include <stdio.h>
int main(void){
    int u = 1;
    int s = -2;
    if (u + s > 0) {          /* 부호 범주를 통일 → -1, 직관대로 거짓 */
        printf("positive\n");
    } else {
        printf("not positive\n");
    }
    return 0;
}

/* Compliant - C99 'false' is essentially Boolean */
( int32_t ) 3U

u16c = u16a +  u16b;               /* Same essential type                */
u32a = ( uint32_t ) u16a + u16b;  /* Cast causes addition in uint32_t   */

u32a += ( u32b + u16b )                /* No composite conversion       */

/* Compliant                             */
( uint16_t ) ( s32a + s32b )

extern void f ( int16_t n );
f ( 1 );             /* Compliant - exception 3 - implicit conversion

fp16 fp5 = f;        /* Compliant - exception 3                          */

struct Opaque;
extern void opaque_reset(struct Opaque *p);  /* 변환 없이 전용 API로만 다룬다 */
void use(struct Opaque *p) {
    opaque_reset(p);
}

const short *p;
const volatile short *q;
q = ( const volatile short * ) p;   /* Compliant */

#include <stdio.h>
#include <stdint.h>
static volatile uint8_t device_register;             /* 실제 객체로 모델링 */
static volatile uint8_t *reg_access(void){ return &device_register; }
int main(void){
    volatile uint8_t *reg = reg_access();   /* 포인터 타입을 유지하는 접근자 */
    *reg = 1u;
    printf("%u\n", (unsigned)device_register);
    return 0;
}

p   = p32;                /* Compliant - pointer to uint32_t into
p   = ( void * ) p16;     /* Compliant                                   */

#include <stdio.h>
static int ctx = 7;
static void use_ctx(void *p){ printf("%d\n", *(int *)p); }
int main(void){
    void *p = &ctx;
    use_ctx(p);   /* 포인터를 포인터 타입 그대로 보관·전달 */
    return 0;
}

pi = cpi;                              /* Compliant - no conversion

int32_t *p2 = ( void * ) 0;   /* Compliant     */
if ( p2 == MY_NULL_2 )    /* Compliant     */

/* Could also be stdio.h, stdlib.h and others */
#include <stddef.h>
extern void f ( uint8_t *p );
/* Compliant for any conforming definition of NULL, such as:

a[ i ]->n;      /* Compliant - no need to write ( a[ i ] )->n          */
*p++;           /* Compliant - no need to write *( p++ )               */
/* Compliant - no need to write f ( ( a + b ), c ) */
/* Compliant */
/* Compliant
/* Compliant
/* Compliant
x = a, b; /* Compliant - parsed as ( x = a ), b */

u8a = u8a  << 7;                 /* Compliant     */
u16a = ( uint16_t ) u8a << 9;   /* Compliant     */
( uint16_t ) 1u << 10u;         /* Compliant     */
1UL << 10u;                     /* Compliant     */

#include <stdio.h>
int main(void){
    int n = 4;
    int j = n;
    for (int i = 0; i < j; i++) {   /* 부작용을 문장으로 분리 — 흐름이 명확 */
        printf("%d-%d ", i, j);
        j--;
    }
    printf("\n");
    return 0;
}

uint16_t y = c + 1u;   /* Compliant */
  uint16_t x = ( 0u == 0u ) ? 0u : ( 0u - 1u );   /* Compliant     */

/* Compliant - no side effects                               */

#include <stdio.h>
int main(void){
    int arr[4] = {0};
    int i = 1;
    arr[i] = i;       /* 사용과 수정을 분리 — 순서에 무관하게 결정적 */
    i++;
    printf("%d %d\n", arr[1], arr[2]);
    return 0;
}

x++;
a[ i ]++;
b.x++;
c->x++;
++( *p );
*p++;
( *p )++;

if ( ( f ( ) + --u8a ) == 0u )
{
}
g ( u8b++ );

x = y;                          /* Compliant                             */

/* Compliant - f ( ) has no persistent side effects            */

s = sizeof ( j );         /* Compliant             */
s = sizeof ( i );         /* Compliant - exception */
s = sizeof ( int32_t );   /* Compliant             */
  s = sizeof ( int32_t[ n ] );                         /* Compliant     */

float32_t f;
for ( uint32_t counter = 0u; counter < 1000u; ++counter )
{
  f = ( float32_t ) counter * 0.001f;
}

float32_t f;
uint32_t  u32a;
f = read_float32 ( );

{
  u32a = read_u32 ( );
  /* f does not change in the loop so cannot be a loop counter */
} while ( ( ( float32_t ) u32a - f ) > 10.0f );

bool_t flag = false;
for ( int16_t i = 0; ( i < 5 ) && !flag; i++ )
{
  if ( C )
  {
    flag = true;                /* Compliant - allows early termination

/* Compliant by exception 1 */
  /* Compliant by exception 2 */

whil e ( q != NULL )   /* Compliant                      */
while ( true )        /* Compliant                      */
while ( flag )        /* Compliant                      */
if ( i != 0 )         /* Compliant                      */

#include <stdio.h>
static int work(void){ return 0; }
static void cleanup(void){ printf("cleanup\n"); }
int main(void){
    int err = 0;
    if (!err) {              /* 구조적 제어문으로 같은 의도를 표현 */
        (void)work();
    }
    cleanup();
    return 0;
}

goto L2;         /* Compliant     */

void f(int a) {
    if (a > 0) {
        goto done;    /* goto 를 감싸는 상위 블록의 라벨로만 점프 */
    }
    a = 1;
done:
    (void)a;
}

for ( x = 0; x < LIMIT; ++x )
{
  if ( ExitNow ( x ) )
  {
    break;
  }
  for ( y = 0; y < x; ++y )
  {
    if ( Exit Now ( LIMIT - y ) )
    {
      break;
    }
  }
}

#include <stdio.h>
static int classify(int x){
    int r;
    if (x < 0)       { r = -1; }     /* 결과를 모아 마지막에 한 번 반환 */
    else if (x == 0) { r = 0; }
    else             { r = x * 2; }
    return r;
}
int main(void){ printf("%d\n", classify(5)); return 0; }

while ( !data_available )
{
}

{
  ;   /* No action required - ; is optional */
}

#include <stdio.h>
int main(void){
    int s = 1;
    switch (s) {
        case 1: {
            int local = 1;      /* 모든 코드를 절(case) 안에, 블록으로 한정 */
            printf("%d\n", local);
            break;
        }
        default:
            break;
    }
    return 0;
}

switch (x) {
    case 1:
        if (flag) { x = 1; }
        break;
    case 2:        /* 모든 라벨이 switch 본문 최상위에 위치 */
        x = 1;
        break;
    default:
        break;
}

break;          /* Compliant - unconditional break                */
  case 1:           /* Compliant - empty fall through allows a group  */

break;
  default:           /* Compliant - default label is present           */
    errorflag = 1;   /* should be non-empty if possible                */
    break;
}
enum Colours
{ RED, GREEN, BLUE } colour;
switch ( colour )
{

switch ( x )
{
  default:   /* Compliant - default is the first label                */

z = 2;
     break;
  default:   /* Compliant                           */
    z = 0;
    break;
}

#include <stdio.h>
#include <stdbool.h>
static bool check(void){ return true; }
int main(void){
    bool ok = check();
    if (ok) {                  /* 불리언 분기는 if-else 로 */
        printf("ok\n");
    } else {
        printf("ng\n");
    }
    return 0;
}

#include <stdio.h>
static int sum(const int *a, int n){   /* 명시적 배열 + 개수 — 타입 안전 */
    int s = 0;
    for (int i = 0; i < n; i++) { s += a[i]; }
    return s;
}
int main(void){
    int a[3] = {1, 2, 3};
    printf("%d\n", sum(a, 3));
    return 0;
}

#include <stdio.h>
static unsigned fact(unsigned n){
    unsigned r = 1u;
    for (unsigned i = 2u; i <= n; i++) { r *= i; }   /* 반복 — 스택 사용 결정적 */
    return r;
}
int main(void){ printf("%u\n", fact(5u)); return 0; }

#include <stdio.h>
static int compute(int x){ return x * 2; }   /* 호출 전에 선언/정의가 보임 */
int main(void){
    int r = compute(3);
    printf("%d\n", r);
    return 0;
}

#include <stdio.h>
static int classify(int x){
    if (x > 0) return 1;
    if (x < 0) return -1;
    return 0;   /* 모든 경로에서 명시적 반환 */
}
int main(void){ printf("%d\n", classify(0)); return 0; }

void sum4(int a[4]);
void caller(void) {
    int four[4] = { 1, 2, 3, 4 };
    sum4(four);    /* 선언된 최소 원소 수를 충족 */
}

#include <stdio.h>
#include <stddef.h>
static int first(const int *a, size_t n){   /* 포인터 + 길이로 명시적 계약 */
    return (n > 0u) ? a[0] : -1;
}
int main(void){
    int a[10] = {7};
    printf("%d\n", first(a, 10));
    return 0;
}

( void ) func ( para2 );   /* Compliant                       */
  x = func ( para2 );        /* Compliant                       */

*p = *q;                    /* Compliant     */

return *( a2 + 9 );           /* Compliant                             */
int32_t *p1 = &c[ 0 ];         /* Compliant                              */
int32_t *p2 = &c[ 10 ];        /* Compliant - points to one beyond       */
p1++;                          /* Compliant                              */
data = *( &data + 0 );         /* Compliant     - C treats data as an
d[ 3 ][ 1 ] = 0;               /* Compliant                              */
data = *( *( d + 3 ) + 1 );    /* Compliant                              */
p1 = d[ 1 ];                   /* Compliant                              */
data = p1[ 1 ];                /* Compliant     - p1 addresses an array
  ++p;         /* Compliant     - p points one beyond s.x                */
p = &s.a[ 0 ]; /* Compliant     - p points into s.a                      */
p = p + 8;     /* Compliant     - p still points into s.a                */

diff = p1 - a1;           /* Compliant     */
  diff = p2 - a2;           /* Compliant     */

if ( p1 < a1 )       /* Compliant     */
  if ( &limits_1.lwb <= &limits_1.upb )   /* Compliant     */

index = index + 1U;     /* Compliant - rule only applies to pointers */
  a[ index ] = 0U;        /* Compliant                                 */
  ptr = &a[ 5 ];          /* Compliant                                 */
  ptr++;                  /* Compliant - increment operator not +      */
  ptr[ 5 ] = 0U;          /* Compliant                                 */
      sum += row[ j ];   /* Compliant */
  p1++;                  /* Compliant     */
  p1[ 5 ] = 0U;          /* Compliant     */
  p2++;                  /* Compliant     */
  p2[ 3 ] = 0U;          /* Compliant     */

int8_t **  obj2;                    /* Compliant     */
   INTPTR *   obj4;                    /* Compliant     */
   int8_t **  arr[ 10 ];               /* Compliant     */
   int8_t **  ( *parr )[ 10 ];         /* Compliant     */
   int8_t *   ( **pparr )[ 10 ];       /* Compliant     */
   int8_t *   s1;                      /* Compliant     */
   int8_t **  s2;                      /* Compliant     */
struct s *   ps1;                      /* Compliant     */
struct s **  ps2;                      /* Compliant     */
int8_t **  (   *pfunc1 )( void );      /* Compliant     */
int8_t **  (  **pfunc2 )( void );      /* Compliant     */

#include <stdio.h>
static void make(int *out){
    *out = 42;        /* 호출자가 소유한 저장소에 기록 */
}
int main(void){
    int value;
    make(&value);     /* 수명이 보장된 객체를 전달 */
    printf("%d\n", value);
    return 0;
}

#include <stdio.h>
#define MAX_DATA 256
struct Packet { int len; char data[MAX_DATA]; };   /* 최대 크기 고정 배열 */
int main(void){
    struct Packet p = { 0, {0} };
    printf("%zu\n", sizeof p);   /* 크기가 정적으로 결정 — 경계 검사 가능 */
    return 0;
}

#include <stdio.h>
#define MAX_N 128
static int sum_first(int n){
    int buf[MAX_N];      /* 컴파일 시 고정 크기 — 스택 사용량 결정적 */
    if (n > MAX_N) { return -1; }
    int s = 0;
    for (int i = 0; i < n; i++) { buf[i] = i; s += buf[i]; }
    return s;
}
int main(void){ printf("%d\n", sum_first(5)); return 0; }

a = b;                    /* Compliant - exception 1 */
  *p = *q;   /* Compliant - exception 1 */

#include <stdio.h>
#include <stdint.h>
#include <string.h>
int main(void){
    uint32_t u = 0x40490FDBu;
    float pi;
    memcpy(&pi, &u, sizeof pi);   /* 명시적 바이트 재해석 — 의도가 분명 */
    printf("%f\n", pi);
    return 0;
}

#include "f1.h"   /* Compliant     */
#include "f2.h"   /* Compliant     */

#include  "filename.h"         /* Compliant     */
#include <filename.h>         /* Compliant     */
#include HEADER               /* Compliant */
#include "./include/cpu.h"    /* Compliant - filename may include a path */

#define unless( E ) if ( ! ( E ) )    /* Compliant                       */
   S1; S2; } while ( false )          /* Compliant                       */
#define compound( S ) { S; }          /* Compliant                       */

/* Remove inline if compiling for C90 */
#define inline

#include <stdio.h>
#define LIMIT_LOW  100   /* 서로 다른 값은 서로 다른 이름으로 */
#define LIMIT_HIGH 200
int main(void){ printf("%d %d\n", LIMIT_LOW, LIMIT_HIGH); return 0; }

#define M1( x, y ) ( x * y )
r = M1 ( 1 + 2, 3 + 4 );

r = ( 1 + 2 * 3 + 4 );

r = M1 ( ( 1 + 2 ), ( 3 + 4 ) );   /* Compliant */
#define M2( x, y ) ( ( x ) * ( y ) )
r = M2 ( 1 + 2, 3 + 4 );           /* Compliant */

#define M3( x ) a ## x = ( x )
int16_t M3 ( 0 );

#define GET_MEMBER( S, M ) ( S ).M
v = GET_MEMBER ( s1, minval );

#if FALSE           /* Compliant                              */
#if ! defined ( X ) /* Compliant                              */
#if A > B           /* Compliant assuming A and B are numeric */

#if defined ( M ) /* Compliant - M is not evaluated               */
#if M == 0        /* Compliant - M is known to be defined         */
/* Compliant - B is only evaluated in ( B == 0 ) if it is defined */

#include <stdio.h>
int main(void){
    int var_abc = 0;   /* 명시적 선언 — 도구로 검색·디버깅이 쉬움 */
    return var_abc;
}

#define A( x )      #x         /* Compliant     */
#define B( x,  y )   x ## y     /* Compliant     */

int32_t speed;
int32_t speed_scale;
int32_t scaled_speed;
#define SCALE( X ) ( ( X ) * X ## _scale )
/* expands to scaled_speed = ( ( speed ) * speed_scale ); */
scaled_speed = SCALE ( speed );

/*
#start is not a token in a comment
 */

#ifdef A               /* Compliant     */
#if 1                  /* Compliant     */

#include <stdio.h>
#define APP_MAX 100      /* 비예약(애플리케이션) 이름 */
int main(void){ printf("%d\n", APP_MAX); return 0; }

/* 고유한 사용자 이름을 사용 */
size_t copy_block(int x) {
    return (size_t)x;
}

#include <stdio.h>
#define MAX_N 256
static int process(int *buf, int n){ int s = 0; for (int i=0;i<n;i++){ buf[i]=i; s+=buf[i]; } return s; }
int main(void){
    int n = 4;
    int buf[MAX_N];               /* 정적/자동 저장소 — 결정적 메모리 */
    if (n > MAX_N) { return 1; }
    printf("%d\n", process(buf, n));
    return 0;
}

#include <stdio.h>
enum { OK = 0, ERR_IO = 1 };
static int do_work(void){ return OK; }
static void recover(void){ printf("recovered\n"); }
int main(void){
    int rc = do_work();          /* 반환값으로 오류를 전파 — 흐름이 명시적 */
    if (rc != OK) { recover(); }
    return 0;
}

#include <stdio.h>
static int stop_requested(void){ return 1; }   /* 상태 플래그를 협조적으로 검사 */
static void step(void){ /* 한 단계 처리 */ }
int main(void){
    while (!stop_requested()) {   /* 협조적 폴링 — 결정적이고 추적 가능 */
        step();
    }
    printf("stopped\n");
    return 0;
}

static void uart_write_str(const char *s){ (void)s; /* 검증된 전용 출력 */ }
static void uart_write_int(const char *label, int v){ (void)label; (void)v; }
int main(void){
    int t = 25;
    uart_write_int("temp=", t);   /* 검증된 전용 입출력 계층 */
    uart_write_str("\n");
    return 0;
}

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <limits.h>
int main(void){
    const char *text = "12345";
    char *end;
    errno = 0;
    long v = strtol(text, &end, 10);
    if (end == text || *end != '\0' || errno == ERANGE || v < INT_MIN || v > INT_MAX) {
        printf("conversion error\n");   /* 오류를 명확히 검출 */
        return 1;
    }
    printf("%d\n", (int)v);
    return 0;
}

static void remove_lock_file(void){ /* 셸 없이 내부 API 로 파일 제거 */ }
int main(void){
    remove_lock_file();   /* 외부 셸 호출·환경 변수 의존 없이 처리 */
    return 0;
}

#include <stdio.h>
static void insertion_sort(int *a, int n){
    for (int i = 1; i < n; i++) {
        int key = a[i], j = i - 1;
        while (j >= 0 && a[j] > key) { a[j + 1] = a[j]; j--; }
        a[j + 1] = key;
    }
}
int main(void){
    int a[5] = {3, 1, 4, 1, 5};
    insertion_sort(a, 5);   /* 검증된 자체 알고리즘 — 결정적 동작 */
    printf("%d\n", a[0]);
    return 0;
}

#include <stdint.h>
#include <stdio.h>
static uint32_t rtc_get_ticks(void){ return 1000u; }   /* 하드웨어 타이머 추상화 */
int main(void){
    uint32_t ticks = rtc_get_ticks();   /* 결정적·검증 가능한 시간 소스 */
    printf("%u\n", ticks);
    return 0;
}

f1 = sqrtf ( f2 );   /* Compliant - float version of sqrt used */

#include <stdio.h>
static int read_fail(FILE *f){ (void)f; return 1; }
int main(void){
    FILE *f = fopen("/etc/hostname", "r");
    if (f == NULL) { return 1; }
    int rc = read_fail(f) ? -1 : 0;
    fclose(f);                         /* 모든 종료 경로에서 해제 */
    return rc;
}

#include <stdlib.h>
int main(void){
    int x = 5;
    (void)x;    /* 자동/정적 객체는 free 하지 않는다(스코프 종료 시 자동 회수) */
    /* 동적 메모리를 쓴다면 할당된 포인터를 정확히 한 번만 free 하고 NULL 로 무효화 */
    return 0;
}

#include <stdio.h>
int main(void){
    FILE *f = fopen("data.bin", "w+");   /* 단일 핸들로 읽기/쓰기 일원화 */
    if (f == NULL) { return 1; }
    fclose(f);
    return 0;
}

pf2 = pf1;      /* Compliant     */

#include <stdio.h>
int main(void){
    FILE *f = fopen("/dev/null", "w");
    if (f == NULL) { return 1; }
    fprintf(f, "x");   /* 닫기 전에 모든 사용을 완료 */
    fclose(f);
    f = NULL;          /* 닫은 뒤 포인터를 무효화 */
    return 0;
}