C言語の変数とは？宣言から初期化・代入・型までやさしく解説

#include <stdio.h>

int main(void) {
    int x;          // int型の変数xを宣言(この時点では中身は未定義)
    x = 42;         // 代入で値を設定
    printf("x = %d\n", x);
    return 0;
}

#include <stdio.h>

int main(void) {
    int a = 1, b = 2, c;   // 同じ型で複数宣言。a,bは同時初期化、cは未初期化
    c = a + b;

    int *p, q;             // pはintへのポインタ、qはintそのもの
    int value = 10;
    p = &value;            // pはアドレスを持つ
    q = value;             // qは値を持つ

    printf("a=%d, b=%d, c=%d\n", a, b, c);
    printf("*p=%d, q=%d\n", *p, q);
    return 0;
}

#include <stdio.h>

int main(void) {
    int a = 10, b = 3;

    a += b;  // a = 13
    a *= 2;  // a = 26
    int c = a = b = 1; // 右から評価されb=1, a=1, c=1

    printf("a=%d, b=%d, c=%d\n", a, b, c);
    return 0;
}

#include <stdio.h>

struct Point { int x, y; };

int main(void) {
    int x = 5;     // 初期化
    x = 7;         // 代入(前の値は上書き)

    int arr[3] = {1, 2, 3}; // 配列の初期化
    // arr = {4, 5, 6};     // エラー: 配列全体への代入は不可

    const int ci = 10; // constは宣言時に値が必要
    // ci = 20;        // エラー: 再代入不可

    struct Point p = { .x = 1, .y = 2 }; // 構造体の初期化
    printf("x=%d, arr[0]=%d, p=(%d,%d)\n", x, arr[0], p.x, p.y);
    return 0;
}

#include <stdio.h>

int main(void) {
    int y;                // 未初期化(中身は不定)
    printf("y = %d\n", y); // 未定義動作: 実行結果は保証されない
    return 0;
}

#include <stdio.h>

int main(void) {
    const int ci = 42;   // 値は変更不可
    // ci = 7;           // エラー

    int v = 10;
    const int *pc = &v;  // 「先がconst」: *pcの変更不可、pcの付け替えは可
    // *pc = 20;         // エラー
    pc = &ci;            // OK

    int *const cp = &v;  // 「ポインタ自体がconst」: cpの付け替え不可、*cpの変更は可
    *cp = 77;            // OK
    // cp = &ci;         // エラー

    printf("v=%d, *pc=%d, *cp=%d\n", v, *pc, *cp);
    return 0;
}

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

int main(void) {
    printf("char:        %zu bytes, CHAR_MIN=%d, CHAR_MAX=%d\n", sizeof(char), CHAR_MIN, CHAR_MAX);
    printf("signed char: %zu bytes, SCHAR_MIN=%d, SCHAR_MAX=%d\n", sizeof(signed char), SCHAR_MIN, SCHAR_MAX);
    printf("short:       %zu bytes, SHRT_MIN=%d, SHRT_MAX=%d\n", sizeof(short), SHRT_MIN, SHRT_MAX);
    printf("int:         %zu bytes, INT_MIN=%d, INT_MAX=%d\n", sizeof(int), INT_MIN, INT_MAX);
    printf("long:        %zu bytes, LONG_MIN=%ld, LONG_MAX=%ld\n", sizeof(long), LONG_MIN, LONG_MAX);
    printf("long long:   %zu bytes, LLONG_MIN=%lld, LLONG_MAX=%lld\n", sizeof(long long), LLONG_MIN, LLONG_MAX);
    printf("unsigned:    0..%u\n", UINT_MAX);
    return 0;
}

#include <stdio.h>
#include <float.h>

int main(void) {
    float f = 1.0f / 3.0f;
    double d = 1.0 / 3.0;
    printf("float  1/3 = %.9f (FLT_DIG=%d)\n", f, FLT_DIG);
    printf("double 1/3 = %.17f (DBL_DIG=%d)\n", d, DBL_DIG);

    double a = 0.1, b = 0.2;
    printf("0.1 + 0.2 = %.17f\n", a + b); // 0.30000000000000004 など
    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void) {
    char s1[] = "Hello";     // 書き換え可能な配列
    s1[0] = 'h';

    const char *s2 = "World"; // 文字列リテラル(書き換え禁止)を指す
    // s2[0] = 'w';           // エラーにすべき。未定義動作の原因

    printf("%s %s! (len=%zu)\n", s1, s2, strlen(s1));
    return 0;
}

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

int main(void) {
    bool ok = (5 > 3);
    printf("ok=%d, !ok=%d\n", ok, !ok); // printfでは整数(0/1)として出力
    return 0;
}

#include <stdio.h>

enum Color { RED = 1, GREEN, BLUE }; // GREEN=2, BLUE=3

int main(void) {
    enum Color c = GREEN;
    printf("c=%d, RED=%d, GREEN=%d, BLUE=%d\n", c, RED, GREEN, BLUE);
    return 0;
}

#include <stdio.h>
#include <string.h>

struct Person {
    char name[16];
    int age;
};

union Number {
    int i;
    float f;
};

int main(void) {
    struct Person p = { "Taro", 20 };
    printf("Person{name=\"%s\", age=%d}, sizeof=%zu\n", p.name, p.age, sizeof p);

    union Number n;
    n.i = 0x3f800000; // IEEE754でおおよそ1.0fに相当するビットパターン
    printf("as int=0x%x, as float=%f, sizeof=%zu\n", n.i, n.f, sizeof n);
    return 0;
}

#include <stdio.h>

size_t count_via_param(int a[], size_t n) {
    // ここでのaはint*に等価。sizeof(a)はポインタのサイズになる
    return n;
}

int main(void) {
    int a[] = {1,2,3,4};
    size_t n = sizeof a / sizeof a[0];
    printf("length=%zu\n", n);
    printf("length via param=%zu\n", count_via_param(a, n));

    int m[2][3] = {{1,2,3}, {4,5,6}}; // 二次元配列
    printf("m[1][2]=%d\n", m[1][2]);
    return 0;
}

#include <stdio.h>

int main(void) {
    int arr[3] = {10, 20, 30};
    int *p = arr;  // arrは式中で&arr[0]に崩壊
    printf("*p=%d, *(p+1)=%d, *(p+2)=%d\n", *p, *(p+1), *(p+2));
    printf("p=%p, p+1=%p\n", (void*)p, (void*)(p+1)); // アドレスは要素サイズ分進む
    return 0;
}

#include <stddef.h>

void add_arrays(size_t n,
                int * restrict dst,
                const int * restrict a,
                const int * restrict b) {
    for (size_t i = 0; i < n; ++i) {
        dst[i] = a[i] + b[i];
    }
}
/* restrictを満たすよう、dst/a/bが重ならないように呼び出します。*/

#include <stdio.h>

int main(void) {
    printf("sizeof(int)=%zu, sizeof(long)=%zu, sizeof(void*)=%zu\n",
           sizeof(int), sizeof(long), sizeof(void*));
    return 0;
}

#include <stdio.h>
#include <inttypes.h>

int main(void) {
    int64_t v = 1234567890123;
    printf("int64_t = %" PRId64 "\n", v);
    return 0;
}

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

int main(void) {
    int a = 1, b = 2;
    double r1 = a / b;          // 整数同士の除算 → 0
    double r2 = (double)a / b;  // 片方をdoubleに変換 → 0.5
    printf("r1=%.1f, r2=%.1f\n", r1, r2);

    unsigned int u = 4000000000u;
    int s = -1;
    // 比較ではsがunsignedに変換されるため予想外の結果になることがある
    printf("s < u ? %s\n", (s < u) ? "true" : "false");

    // 明示的キャストは慎重に
    signed char sc = (signed char)200; // 実装依存の結果
    printf("cast to signed char: %d\n", sc);
    return 0;
}

#include <stdio.h>

int main(void) {
    int x = 10;         // 外側のx
    {
        int x = 20;     // 内側のx(外側を隠す)
        printf("inner x=%d\n", x);
    }
    printf("outer x=%d\n", x);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int *leak_example(void) {
    int *p = malloc(sizeof *p); // 動的確保(呼び出し側でfreeが必要)
    *p = 123;
    return p;
}

int *dangling_pointer(void) {
    int local = 42;
    // return &local; // エラー: ローカルの寿命終了後はダングリングポインタ
    return NULL;
}

int main(void) {
    int *p = leak_example();
    printf("*p=%d\n", *p);
    free(p); // 解放を忘れない
    return 0;
}

/* counter.c */
#include <stdio.h>

int counter = 0;      // 定義(ストレージを確保)
void inc(void) { counter++; }
void show(void) { printf("counter=%d\n", counter); }

/* main.c */
#include <stdio.h>

extern int counter;   // 参照用の宣言(定義ではない)
void inc(void);
void show(void);

int main(void) {
    inc();
    inc();
    show();
    printf("mainからも参照: counter=%d\n", counter);
    return 0;
}

/* module.c */
#include <stdio.h>

static int hidden = 42; // 他ファイルからは参照不可
int public_data = 7;    // 外部リンケージ

void show_hidden(void) { printf("hidden=%d\n", hidden); }

/* other.c */
extern int public_data;
// extern int hidden; // リンクエラー: hiddenは内部リンケージ

int main(void) {
    extern void show_hidden(void);
    show_hidden();
    printf("public_data=%d\n", public_data);
    return 0;
}

#include <stdio.h>

void counter(void) {
    static int c = 0; // 初回は0で初期化。以降は値を保持
    c++;
    printf("c=%d\n", c);
}

int main(void) {
    counter();
    counter();
    counter();
    return 0;
}

/* C11スレッドの例 */
#include <stdio.h>
#include <threads.h>    // C11
#include <stdlib.h>

_Thread_local int tls_var = 0; // スレッド局所

int thread_func(void *arg) {
    int id = *(int*)arg;
    tls_var = id; // 各スレッドが独自に値を設定
    printf("thread %d: tls_var=%d, &tls_var=%p\n", id, tls_var, (void*)&tls_var);
    return 0;
}

int main(void) {
    thrd_t t1, t2;
    int a = 1, b = 2;
    thrd_create(&t1, thread_func, &a);
    thrd_create(&t2, thread_func, &b);
    thrd_join(t1, NULL);
    thrd_join(t2, NULL);
    printf("main thread: tls_var=%d, &tls_var=%p\n", tls_var, (void*)&tls_var);
    return 0;
}