C言語のデータ型まとめ 種類の違いと選び方、値の範囲を解説

// 型のサイズと範囲を調べるサンプル
// コンパイル例: gcc -std=c11 -Wall -Wextra -O2 types_info.c -o types_info
#include <stdio.h>
#include <limits.h>   // 整数の範囲(CHAR_MIN, INT_MAX など)
#include <float.h>    // 浮動小数点の範囲(FLT_MIN, DBL_MAX など)
#include <stdint.h>   // SIZE_MAX など
#include <stddef.h>   // ptrdiff_t

int main(void) {
    printf("== サイズ(バイト) ==\n");
    printf("char           : %zu (CHAR_BIT=%d)\n", sizeof(char), CHAR_BIT);
    printf("signed char    : %zu\n", sizeof(signed char));
    printf("unsigned char  : %zu\n", sizeof(unsigned char));
    printf("short          : %zu\n", sizeof(short));
    printf("int            : %zu\n", sizeof(int));
    printf("long           : %zu\n", sizeof(long));
    printf("long long      : %zu\n", sizeof(long long));
    printf("size_t         : %zu\n", sizeof(size_t));
    printf("ptrdiff_t      : %zu\n", sizeof(ptrdiff_t));
    printf("void*          : %zu\n", sizeof(void*));
    printf("float          : %zu\n", sizeof(float));
    printf("double         : %zu\n", sizeof(double));
    printf("long double    : %zu\n\n", sizeof(long double));

    printf("== 範囲(整数) ==\n");
    printf("char (plain)   : %d .. %d\n", CHAR_MIN, CHAR_MAX);             // 実装依存(符号付き/なし)
    printf("signed char    : %d .. %d\n", SCHAR_MIN, SCHAR_MAX);
    printf("unsigned char  : %u .. %u\n", 0u, UCHAR_MAX);
    printf("short          : %d .. %d\n", SHRT_MIN, SHRT_MAX);
    printf("unsigned short : %u .. %u\n", 0u, USHRT_MAX);
    printf("int            : %d .. %d\n", INT_MIN, INT_MAX);
    printf("unsigned int   : %u .. %u\n", 0u, UINT_MAX);
    printf("long           : %ld .. %ld\n", LONG_MIN, LONG_MAX);
    printf("unsigned long  : %lu .. %lu\n", 0ul, ULONG_MAX);
    printf("long long      : %lld .. %lld\n", LLONG_MIN, LLONG_MAX);
    printf("unsigned long long: %llu .. %llu\n", 0ull, ULLONG_MAX);
    printf("size_t (max)   : 0 .. %zu\n", SIZE_MAX);
    printf("ptrdiff_t      : %td .. %td\n\n", (ptrdiff_t)PTRDIFF_MIN, (ptrdiff_t)PTRDIFF_MAX);

    printf("== 範囲(浮動小数点, 正規化数の最小) ==\n");
    printf("float       : min=%.9g max=%.9g (digits=%d)\n", FLT_MIN, FLT_MAX, FLT_DIG);
    printf("double      : min=%.17g max=%.17g (digits=%d)\n", DBL_MIN, DBL_MAX, DBL_DIG);
    printf("long double : min=%Lg max=%Lg (digits=%d)\n", LDBL_MIN, LDBL_MAX, LDBL_DIG);
    printf("epsilon     : float=%g double=%g long double=%Lg\n", FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON);
    return 0;
}

// 固定幅整数とprintfマクロの例
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {
    int32_t a = INT32_MAX;
    uint64_t b = 12345678901234567890ull;
    printf("a(int32_t) = %" PRId32 "\n", a);
    printf("b(uint64_t) = %" PRIu64 "\n", b);
    return 0;
}

// size_t と ptrdiff_t の基本
#include <stdio.h>
#include <stddef.h>

int main(void) {
    int a[10] = {0};
    int *p = &a[2];
    int *q = &a[8];
    size_t n = sizeof(a) / sizeof(a[0]); // 要素数
    ptrdiff_t d = q - p;                  // 要素単位の距離

    printf("配列の要素数(size_t): %zu\n", n);
    printf("q - p の距離(ptrdiff_t): %td\n", d);
    return 0;
}

// 整数のリテラルとprintfの組み合わせ例
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {
    int i = 42;
    unsigned u = 42U;
    long l = 100000L;
    long long ll = 10000000000LL;
    int32_t i32 = -123;
    uint64_t u64 = 18446744073709551615ull;

    printf("int=%d, unsigned=%u, long=%ld, long long=%lld\n", i, u, l, ll);
    printf("i32=%" PRId32 ", u64=%" PRIu64 "\n", i32, u64);
    return 0;
}

// 文字・文字列の基本
#include <stdio.h>
#include <string.h>

int main(void) {
    char c = 'C';                 // 文字(型はcharだが、文字リテラルはintとして扱われる場面もある)
    const char *p = "C language"; // 文字列リテラルは静的領域(書き換え禁止)
    char s[16];                   // 十分な大きさのバッファを用意

    // 安全なコピー: snprintfは終端も保証
    snprintf(s, sizeof(s), "%s", p);

    printf("char: %c, 文字コード: %d\n", c, (int)c);
    printf("文字列: %s (長さ: %zu)\n", s, strlen(s));
    return 0;
}

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    bool a = true;
    bool b = (5 > 10);
    printf("a=%d, b=%d\n", a, b); // 1と0で表示
    return 0;
}

// 浮動小数点と文字/文字列のprintf書式
#include <stdio.h>

int main(void) {
    float f = 3.1415926f;
    double d = 2.718281828459045;
    long double ld = 1.234567890123456789L;
    char ch = 'A';
    const char *str = "hello";

    printf("float  %%f=%.3f %%e=%.3e %%g=%.3g\n", f, f, f);
    printf("double %%f=%.6f %%e=%.6e %%g=%.6g\n", d, d, d);
    printf("long double %%Lf=%.9Lf\n", ld);
    printf("char= %c, string= %s\n", ch, str);
    return 0;
}

// 符号混在と整数昇格の落とし穴
#include <stdio.h>

int main(void) {
    int i = -1;
    unsigned int u = 1u;

    // 比較ではuがunsignedのため、iがunsignedに変換されて非常に大きな値になる
    printf("i < u ? %d\n", (i < u)); // 多くの処理系で0(false)

    signed char sc1 = 100, sc2 = 50;
    printf("sc1 + sc2 = %d\n", sc1 + sc2); // intに昇格して計算

    unsigned char uc = 250;
    signed char sc = 10;
    // uc(250) + sc(10)=260 -> 昇格後intで計算。格納時の型で再び丸め/オーバーフローに注意
    int sum = uc + sc;
    printf("uc + sc = %d\n", sum);
    return 0;
}

// double -> int への安全なキャスト(飽和)
#include <stdio.h>
#include <limits.h>

int safe_cast_double_to_int(double x, int *out) {
    if (x > (double)INT_MAX) { *out = INT_MAX; return 1; } // 1: 飽和
    if (x < (double)INT_MIN) { *out = INT_MIN; return 1; }
    *out = (int)x; // 範囲内ならキャスト
    return 0;      // 0: 正常
}

int main(void) {
    double v1 = 1e20, v2 = -1e20, v3 = 123.9;
    int r;
    safe_cast_double_to_int(v1, &r); printf("v1->%d\n", r);
    safe_cast_double_to_int(v2, &r); printf("v2->%d\n", r);
    safe_cast_double_to_int(v3, &r); printf("v3->%d\n", r);
    return 0;
}

// intの安全な加算チェック
#include <stdio.h>
#include <limits.h>

int add_int_safe(int a, int b, int *out) {
    if ((b > 0 && a > INT_MAX - b) || (b < 0 && a < INT_MIN - b)) {
        return 1; // オーバーフロー
    }
    *out = a + b;
    return 0;
}

int main(void) {
    int r;
    if (add_int_safe(INT_MAX, 1, &r)) {
        printf("オーバーフロー検出\n");
    }
    if (!add_int_safe(100, 23, &r)) {
        printf("100 + 23 = %d\n", r);
    }
    return 0;
}

// 浮動小数点の近似比較
#include <stdio.h>
#include <float.h>
#include <math.h>

int nearly_equal(double a, double b, double eps) {
    double diff = fabs(a - b);
    double scale = fmax(1.0, fmax(fabs(a), fabs(b)));
    return diff <= eps * scale;
}

int main(void) {
    double x = 0.1 + 0.2; // 0.30000000000000004 になることが多い
    printf("x=%.17f, 0.3=%.17f, equal? %d\n", x, 0.3, nearly_equal(x, 0.3, 10 * DBL_EPSILON));
    return 0;
}