【C言語】値渡しだと変わらない? 参照渡しとの違いと落とし穴

#include <stdio.h>

// x は「呼び出し側 a のコピー」
void add_ten(int x) {
    x += 10; // コピー側だけが変わる
    printf("add_ten内: x = %d\n", x);
}

int main(void) {
    int a = 5;
    add_ten(a);
    printf("main側: a = %d\n", a); // 変わらない
    return 0;
}

#include <stdio.h>

void set_zero(int x) {
    x = 0; // コピーを0にしているだけ
}

int main(void) {
    int a = 7;
    set_zero(a);
    printf("a = %d\n", a); // 7のまま
    return 0;
}

#include <stdio.h>

int add(int a, int b) {
    // a, b はコピーだが、結果を戻り値で返す
    return a + b;
}

int main(void) {
    int x = 10, y = 32;
    int sum = add(x, y);
    printf("sum = %d\n", sum);
    return 0;
}

// 実行しないこと: 未定義動作の例
#include <stdio.h>

int* bad_address(void) {
    int local = 42;          // 関数終了で消える
    return &local;           // ダングリングポインタ(危険)
}

int main(void) {
    int *p = bad_address();  // ここで p は無効なアドレス
    // printf("%d\n", *p);   // 未定義動作。実行しないこと。
    return 0;
}

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

int make_value(void) {
    int v = 42;
    return v; // 値で返す(安全)
}

void fill_out_param(int *out) {
    if (out) *out = 42; // outに書き込む
}

int* make_heap_value(void) {
    int *p = malloc(sizeof *p);
    if (p) *p = 42;
    return p; // 動的確保して返す(呼び出し側でfree)
}

int* static_address(void) {
    static int s = 42; // 静的記憶域期間
    return &s;         // 生存期間はプログラム終了まで
}

int main(void) {
    int a = make_value();
    printf("a = %d\n", a);

    int b;
    fill_out_param(&b);
    printf("b = %d\n", b);

    int *c = make_heap_value();
    if (c) {
        printf("c = %d\n", *c);
        free(c);
    }

    int *d = static_address();
    printf("d = %d\n", *d);

    return 0;
}

#include <stdio.h>

void increment(int *p) {
    if (p) {
        (*p)++; // アドレス先の値を変更 => 呼び出し元に反映
    }
}

int main(void) {
    int a = 10;
    increment(&a);
    printf("a = %d\n", a); // 11
    return 0;
}

#include <stdio.h>

void swap_bad(int a, int b) {
    int t = a; a = b; b = t; // コピーの交換
}

int main(void) {
    int x = 1, y = 2;
    swap_bad(x, y);
    printf("x = %d, y = %d\n", x, y); // 変わらない
    return 0;
}

#include <stdio.h>

void swap(int *a, int *b) {
    if (!a || !b) return;
    int t = *a; *a = *b; *b = t;
}

int main(void) {
    int x = 1, y = 2;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y); // 入れ替わる
    return 0;
}

#include <stdio.h>

void show_in_func(int a[5]) { // 実際の型は int* に等価
    printf("関数内 sizeof(a) = %zu (ポインタの大きさ)\n", sizeof a);
    a[0] = 99; // 要素は書き換わる(同じ配列領域を指す)
}

int main(void) {
    int a[5] = {1,2,3,4,5};
    printf("main側 sizeof(a) = %zu (配列全体)\n", sizeof a);
    show_in_func(a);
    printf("a[0] = %d\n", a[0]); // 99 に変化
    return 0;
}

#include <stdio.h>
#include <ctype.h>

// 読むだけ => const char*
void print_msg(const char *s) {
    if (s) printf("%s\n", s);
}

// 書き換える => char*
void to_upper_inplace(char *s) {
    if (!s) return;
    for (; *s; ++s) {
        *s = (char)toupper((unsigned char)*s);
    }
}

int main(void) {
    const char *lit = "Hello, world"; // リテラル(不変)
    print_msg(lit);

    // to_upper_inplace(lit); // だめ: リテラルは書き換え不可

    char buf[] = "mutable";
    to_upper_inplace(buf); // バッファは書き換え可能
    printf("%s\n", buf);

    return 0;
}

#include <stdio.h>

typedef struct {
    int data[1000]; // 大きめ
} Big;

void init_by_value(Big b) {      // 全体コピーが発生
    b.data[0] = 123;             // 呼び出し元は変わらない
}

void init_by_pointer(Big *b) {   // アドレスだけ渡す
    if (b) b->data[0] = 456;     // 呼び出し元に反映
}

int main(void) {
    Big x = {0};

    printf("sizeof(Big) = %zu\n", sizeof(Big));
    init_by_value(x);
    printf("after by_value: x.data[0] = %d\n", x.data[0]); // 0のまま

    init_by_pointer(&x);
    printf("after by_pointer: x.data[0] = %d\n", x.data[0]); // 456

    return 0;
}

// 実行しないこと: 未定義動作の例
int* make_array_bad(void) {
    int a[3] = {1,2,3}; // ローカル配列(関数終了で消える)
    return a;           // ダングリングポインタ(危険)
}

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

void reassign_bad(int *p) {
    // p は呼び出し元ポインタの「コピー」
    int *tmp = malloc(3 * sizeof *tmp);
    if (tmp) {
        tmp[0] = 10; tmp[1] = 20; tmp[2] = 30;
    }
    p = tmp; // 呼び出し元のポインタは変わらない(無効)
}

void reassign_good(int **pp) {
    // pp 経由で呼び出し元のポインタを書き換える
    int *tmp = malloc(3 * sizeof *tmp);
    if (tmp) {
        tmp[0] = 1; tmp[1] = 2; tmp[2] = 3;
    }
    *pp = tmp; // 呼び出し元に反映
}

int main(void) {
    int *arr = NULL;

    reassign_bad(arr);  // 効果なし
    printf("after bad: arr = %p\n", (void*)arr);

    reassign_good(&arr); // arr が新しいアドレスに更新される
    if (arr) {
        printf("after good: arr = %p, [%d,%d,%d]\n",
               (void*)arr, arr[0], arr[1], arr[2]);
        free(arr);
    }
    return 0;
}

#include <stdio.h>

// 入力のみ: 配列内容は読めるが変えない
int sum_array(const int *arr, size_t n) {
    int s = 0;
    for (size_t i = 0; i < n; ++i) s += arr[i];
    return s;
}

// 入出力: 配列内容を更新する
void scale_array(int *arr, size_t n, int k) {
    for (size_t i = 0; i < n; ++i) arr[i] *= k;
}

int main(void) {
    int a[5] = {1,2,3,4,5};
    printf("sum = %d\n", sum_array(a, 5));
    scale_array(a, 5, 2);
    printf("a[0] = %d\n", a[0]);
    return 0;
}