[C언어 50강] 08강. 형 변환: 묵시적/명시적 캐스팅, 오버플로/정밀도 이슈

Last updated on 18 2월 2026

C언어에서 버그가 가장 조용하게 발생하는 구간 중 하나가 바로 형 변환입니다. 컴파일은 잘 되는데 결과가 어긋나고, 원인 추적은 어려운 경우가 많죠. 오늘은 묵시적/명시적 캐스팅, 오버플로, 정밀도 손실을 하나의 흐름으로 묶어 "컴파일러가 타입을 어떻게 바꿔서 계산하는가"를 개념 중심으로 정리해보겠습니다.

핵심 개념

C의 연산은 선언된 타입 그대로만 진행되지 않는다. 연산 전 "정수 승격(integer promotion)"과 "usual arithmetic conversions"가 먼저 일어난다.
형 변환은 값의 해석 방식을 바꾸는 일이지, 마법처럼 데이터가 보존되는 과정이 아니다. 범위를 벗어나면 오버플로/손실이 생긴다.
명시적 캐스팅 (type)은 의도를 드러내는 좋은 도구이지만, 잘못 쓰면 위험을 가리는 주석 같은 존재가 된다.

개념 먼저 이해하기

C에서 형 변환을 이해하려면 먼저 "변수의 타입"과 "연산의 타입"을 분리해서 생각해야 합니다. 예를 들어 char a, short b를 더할 때, 실제 CPU가 char와 short 그대로 계산하는 것이 아닙니다. C 표준 규칙에 따라 먼저 더 큰 정수 타입(보통 int)으로 승격한 뒤 계산합니다. 즉 우리가 작성한 코드와 컴파일러가 실제 생성한 계산 모델 사이에는 중간 단계가 존재합니다. 초보자는 이 중간 단계를 놓치고 "나는 int로 안 썼는데 왜 int처럼 동작하지?" 같은 혼란을 겪습니다.

두 번째로 중요한 포인트는 "타입 변환은 값을 복사/보존하는 행위가 아니라, 비트 패턴을 다른 규칙으로 해석하거나 새로운 타입의 표현 범위에 맞춰 재인코딩하는 행위"라는 점입니다. 예를 들어 double을 int로 바꾸면 소수부는 잘립니다(반올림이 아님). 1000을 char로 바꾸면 구현 환경에 따라 값이 깨질 수 있습니다. 범위를 벗어난 값을 더 작은 타입으로 밀어 넣는 순간, 우리가 기대한 수학적 값과 컴퓨터 내부 값은 분리됩니다. 이 차이를 이해하지 못하면 버그를 "랜덤"으로 느끼게 됩니다.

세 번째는 부호(signed/unsigned) 혼합 연산입니다. C 실무 버그의 단골입니다. int n = -1; unsigned int m = 1;일 때 n < m이 직관과 다르게 나올 수 있습니다. 왜냐하면 비교 전에 한쪽 타입이 다른 쪽으로 변환되는데, 이 과정에서 -1이 매우 큰 양수로 해석될 수 있기 때문입니다. 문제는 코드가 아주 자연스럽게 보인다는 데 있습니다. 팀 코드 리뷰에서 "부호가 다른 정수끼리 비교/연산했는가"를 반드시 확인하는 이유가 여기 있습니다.

네 번째는 오버플로와 정밀도 손실의 구분입니다. 오버플로는 표현 가능한 범위를 넘는 문제이고, 정밀도 손실은 범위 안에 있더라도 표현의 해상도가 부족해 정보가 사라지는 문제입니다. 예를 들어 int 덧셈에서 최대값을 넘으면 오버플로 위험이 있고, float에서 매우 큰 수와 매우 작은 수를 더하면 작은 수가 사라지는 정밀도 손실이 발생할 수 있습니다. 둘 다 결과가 "틀린 것처럼" 보이지만 원인이 다르므로 대응 방식도 달라야 합니다.

다섯 번째는 명시적 캐스팅의 역할입니다. 캐스팅은 나쁜 것이 아닙니다. 오히려 의도를 명확히 하고 경고를 줄이며 API 계약을 맞추는 데 필수입니다. 다만 "경고를 없애기 위해 무조건 캐스팅"하는 습관은 위험합니다. 특히 포인터 캐스팅, 부호 캐스팅, 폭이 좁은 타입으로의 캐스팅은 코드의 안전장치를 우회하기 쉽습니다. 올바른 접근은 캐스팅을 하기 전에 범위를 검증하고, 왜 이 변환이 안전한지 근거를 코드 구조로 보여주는 것입니다.

정리하면, 형 변환은 문법 요소가 아니라 실행 모델입니다. 계산 전에 어떤 타입으로 승격되는지, 결과를 어느 타입에 담을 때 어떤 손실이 생기는지, 부호가 섞이면 어떤 재해석이 일어나는지를 한 번에 보는 습관이 필요합니다. C를 오래 쓸수록 "연산식 한 줄"을 읽을 때 자동으로 변환 경로를 떠올리는 능력이 중요해집니다. 그 습관이 생기면 디버깅 시간이 체감상 절반 이하로 줄어듭니다.

기본 사용

예제 1) 정수 나눗셈과 명시적 캐스팅

#include <stdio.h>

int main(void) {
    int sum = 7;
    int count = 2;

    double avg_wrong = sum / count;          // int / int -> int(3) 후 double 저장
    double avg_right = (double)sum / count;  // double / int -> double 연산

    printf("avg_wrong = %.2f\n", avg_wrong);
    printf("avg_right = %.2f\n", avg_right);
    return 0;
}

설명:

sum / count는 결과를 double에 담더라도 연산 자체는 이미 정수 나눗셈으로 끝납니다.
평균/비율 계산에서 캐스팅 위치는 "저장 타입"보다 "연산 시점"이 더 중요합니다.
실무에서는 (double)sum / (double)count처럼 의도를 더 명확히 적는 것도 좋습니다.

예제 2) signed/unsigned 혼합 비교의 함정

#include <stdio.h>

int main(void) {
    int temperature = -1;
    unsigned int threshold = 1;

    if (temperature < threshold) {
        printf("temperature is smaller\n");
    } else {
        printf("unexpected: temperature is NOT smaller\n");
    }

    printf("temperature as unsigned = %u\n", (unsigned int)temperature);
    return 0;
}

설명:

비교 전에 temperature가 unsigned로 변환될 수 있어, 매우 큰 값으로 해석됩니다.
논리적으로 자연스러운 비교도 타입 규칙 때문에 반대로 동작할 수 있습니다.
해결책은 같은 부호/폭의 타입으로 맞추는 것입니다. 타입 설계가 먼저입니다.

예제 3) 범위 검증 후 안전한 축소 변환

#include <stdio.h>
#include <limits.h>

int to_short_checked(int value, short *out) {
    if (value < SHRT_MIN || value > SHRT_MAX) {
        return -1; // 변환 불가
    }
    *out = (short)value;
    return 0;
}

int main(void) {
    int x1 = 1200;
    int x2 = 100000;
    short s;

    if (to_short_checked(x1, &s) == 0) {
        printf("x1 -> short: %d\n", s);
    }
    if (to_short_checked(x2, &s) != 0) {
        printf("x2는 short 범위를 벗어나 변환 거부\n");
    }
    return 0;
}

설명:

단순 캐스팅보다 "검증 + 변환" 패턴이 훨씬 안전합니다.
라이브 데이터(파일, 네트워크, 사용자 입력)에서는 축소 변환 전에 경계 체크가 필수입니다.
실패를 반환값으로 분리하면 디버깅과 에러 처리가 명확해집니다.

예제 4) 부동소수점 정밀도 손실 관찰

#include <stdio.h>

int main(void) {
    float big = 100000000.0f;
    float small = 1.0f;

    float result = big + small;

    printf("big     = %.1f\n", big);
    printf("small   = %.1f\n", small);
    printf("result  = %.1f\n", result);
    printf("delta   = %.1f\n", result - big);
    return 0;
}

설명:

float의 유효 자릿수 한계 때문에 큰 수에 작은 수를 더해도 변화가 반영되지 않을 수 있습니다.
이것은 오버플로가 아니라 정밀도 해상도 문제입니다.
금액, 통계, 누적 합산에서는 자료형 선택(double, 고정소수점 전략)이 성능만큼 중요합니다.

자주 하는 실수

실수 1) 결과 저장 타입만 바꾸면 연산 방식도 바뀐다고 착각

원인: double x = a / b;처럼 저장 변수 타입만 보고 안심함.
해결: 연산식 내부 피연산자 타입을 먼저 확인하고, 필요한 위치에 명시적 캐스팅을 넣습니다.

실수 2) 경고를 없애기 위해 무의미한 캐스팅 남발

원인: 컴파일 경고를 "불편한 소음"으로만 생각해 강제 캐스팅으로 덮음.
해결: 경고 원인을 먼저 해결합니다. 캐스팅은 안전성 근거가 있을 때만 사용합니다.

실수 3) signed/unsigned 혼합 비교를 습관적으로 작성

원인: 라이브러리 반환값(size_t)과 사용자 변수(int)를 그대로 섞음.
해결: 타입을 일관되게 설계하고, 필요하면 비교 전 검증 후 안전하게 변환합니다.

실수 4) 축소 변환 시 범위 체크 생략

원인: 테스트 입력이 작아서 문제를 못 본 채 배포됨.
해결: limits.h 기반 경계 검사 함수를 공용 유틸로 만들어 재사용합니다.

실무 패턴

수치 연산 API는 입력/출력 타입을 문서화하고, 함수명으로 의도를 드러냅니다. 예: calc_ratio_double().
외부 입력 파싱 후 바로 축소 타입에 담지 말고, 넓은 타입(long long/double)에서 검증 후 변환합니다.
컴파일 옵션에서 경고를 적극 활용합니다: -Wall -Wextra -Wconversion -Wsign-conversion.
리뷰 체크리스트에 "혼합 부호 연산 여부", "축소 변환 전 검증 여부", "캐스팅 근거 주석/구조"를 포함합니다.
성능 최적화보다 먼저 수치 정확성 요구사항(허용 오차, 범위, 반올림 규칙)을 명세로 고정합니다.

오늘의 결론

한 줄 요약: 형 변환은 타입 표기 문제가 아니라 계산 규칙의 문제이며, "언제 어떤 타입으로 계산되는지"를 통제해야 오버플로와 정밀도 버그를 막을 수 있습니다.

연습문제

int total = 13, n = 5;에서 평균을 소수 둘째 자리까지 올바르게 계산해 출력하세요. 왜 기존 total / n이 틀렸는지도 설명하세요.
int a = -20; unsigned int b = 10; 비교가 직관과 다를 수 있음을 재현하고, 타입을 안전하게 맞춘 수정 버전을 작성하세요.
사용자 입력 정수를 short로 저장하려고 합니다. 범위 검증 함수를 작성하고, 실패 시 에러 메시지를 출력하는 흐름을 구현하세요.

이전 강의 정답

지난 7강(비교/논리 연산자, 단락 평가) 연습문제 해설:

x가 10 이상 99 이하인지 판별

정답 식: x >= 10 && x <= 99
이유: 하한/상한을 동시에 만족해야 하므로 AND(&&)를 사용합니다.

char *name = NULL;에서 안전한 문자열 검사

정답 예시: name != NULL && name[0] != '\0'
이유: 널 포인터 여부를 먼저 검사해야 오른쪽 접근이 안전합니다(단락 평가).

부작용 리팩터링

기존: if (ready || ++retry_count < 3) { ... }
개선:
- if (!ready) { retry_count++; }
- if (ready || retry_count < 3) { ... }
이유: 상태 변경과 조건 판단을 분리해 예측 가능성과 가독성을 높입니다.

실습 환경/재현 정보

컴파일러: Apple clang 17.x 또는 GCC 13+
컴파일 옵션: -std=c11 -Wall -Wextra -Wconversion -Wsign-conversion -O0
실행 환경: macOS (arm64), 터미널 zsh
재현 체크:
- clang -std=c11 -Wall -Wextra -Wconversion -Wsign-conversion -O0 lesson08.c -o lesson08
- ./lesson08
- 정수 나눗셈/부호 혼합/정밀도 예제를 각각 실행해 출력 차이를 확인합니다.