【C言語】符号あり整数と符号なし整数の違い(signed, unsigned)

// 範囲を確認するプログラム(range_check.c)
#include <stdio.h>
#include <limits.h>

int main(void) {
    // sizeofで実際のバイト数を確認できます
    printf("sizeof(int) = %zu bytes\n", sizeof(int));
    printf("INT_MIN = %d\n", INT_MIN);
    printf("INT_MAX = %d\n", INT_MAX);
    printf("UINT_MAX = %u\n", UINT_MAX);
    return 0;
}

// 比較での自動変換の例(signed_vs_unsigned_compare.c)
#include <stdio.h>

int main(void) {
    int si = -1;          // 符号あり: -1
    unsigned int ui = 1u; // 符号なし: 1

    printf("si = %d, ui = %u\n", si, ui);

    // ここで si は unsigned に変換される
    printf("si < ui ? %s\n", (si < ui) ? "true" : "false");

    // リテラルと混在した場合 (-1 は int、0u は unsigned int)
    printf("-1 < 0u ? %s\n", ((-1) < 0u) ? "true" : "false");

    return 0;
}

// オーバーフロー/アンダーフローの挙動(overflow_underflow.c)
#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int um = UINT_MAX;
    printf("UINT_MAX = %u\n", um);

    // unsigned の加算は 2^N で折り返す(定義済みの挙動)
    unsigned int wrap_add = um + 1u;     // 0 に戻る
    unsigned int wrap_sub = 0u - 1u;     // UINT_MAX になる

    printf("UINT_MAX + 1 => %u\n", wrap_add);
    printf("0u - 1u      => %u\n", wrap_sub);

    // signed のオーバーフローは未定義なので、実演しない
    // 代わりに安全な加算のガード例を示す
    int a = INT_MAX, b = 1;
    if (b > 0 && a > INT_MAX - b) {
        printf("安全: これ以上加算すると signed のオーバーフローになります\n");
    } else {
        printf("安全: a + b = %d\n", a + b);
    }
    return 0;
}

// 危険な例: 無限ループになる恐れ(コンパイルはできますが実行しないでください)
/*
for (unsigned i = n - 1; i >= 0; --i) {
    // i は常に 0 以上なので条件 i >= 0 は常に真
    // 0 から 1 を引くと折り返して非常に大きな値になり、永遠に終わりません
}
*/

// 安全なループ例(loop_patterns.c)
#include <stdio.h>
#include <stddef.h>

int main(void) {
    size_t n = 5;

    // 昇順: 最も安全で読みやすい
    printf("Ascending: ");
    for (size_t i = 0; i < n; ++i) {
        printf("%zu ", i);
    }
    printf("\n");

    // 降順: i-- > 0 パターン (i は 0 で止まる)
    printf("Descending: ");
    for (size_t i = n; i-- > 0; ) {
        printf("%zu ", i);
    }
    printf("\n");

    return 0;
}

// 負の値を unsigned に変換(neg_to_unsigned.c)
#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int u1 = (unsigned int)-1;
    unsigned int u2 = (unsigned int)-123;

    printf("(unsigned)-1   = %u (期待: UINT_MAX)\n", u1);
    printf("(unsigned)-123 = %u (期待: UINT_MAX - 122)\n", u2);
    printf("UINT_MAX       = %u\n", UINT_MAX);
    printf("UINT_MAX - 122 = %u\n", UINT_MAX - 122u);
    return 0;
}

// 個数(サイズ)には size_t を使う(size_usage.c)
#include <stdio.h>
#include <stddef.h>

int main(void) {
    int arr[3] = {10, 20, 30};
    size_t n = sizeof(arr) / sizeof(arr[0]);

    for (size_t i = 0; i < n; ++i) {
        printf("arr[%zu] = %d\n", i, arr[i]);
    }
    return 0;
}

// フラグ操作の基本(bit_flags.c)
#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint32_t flags = 0u;         // 32ビットの符号なし(明確で安全)
    const uint32_t FLAG_A = 1u << 0; // ビット0
    const uint32_t FLAG_B = 1u << 1; // ビット1

    // 立てる(OR)
    flags |= FLAG_A;
    flags |= FLAG_B;

    // 調べる(AND)
    printf("FLAG_A? %s\n", (flags & FLAG_A) ? "ON" : "OFF");
    printf("FLAG_B? %s\n", (flags & FLAG_B) ? "ON" : "OFF");

    // 落とす(AND NOT)
    flags &= ~FLAG_A;
    printf("FLAG_A after clear? %s\n", (flags & FLAG_A) ? "ON" : "OFF");

    return 0;
}

// リテラル接尾辞の挙動(literal_suffix.c)
#include <stdio.h>

int main(void) {
    printf("1 - 2  = %d\n", 1 - 2);      // signed の計算 => -1
    printf("1u - 2 = %u\n", 1u - 2u);    // unsigned の計算 => 折り返して巨大値

    // 16進のマスクにも u を付けると安全
    unsigned int mask = 0xFFu; // 下位8ビット
    printf("mask = %u\n", mask);

    return 0;
}