[入門] C/C++ 知っておくべきポインタの由来 ISO標準のメモリモデル徹底解説

// 逆数の近似計算（ニュートン・ラフソン法）
void recip(double* ap, double* rp) {
    for (;;) {
        double prod = (*ap)*(*rp);
        if ((0.999999 < prod) && (prod < 1.000001)) {
            break;
        } else {
            (*rp) *= (2.0 - prod);
        }
    }
}

// 手動最適化版（危険！）
void recip_opt(double* ap, double* rp) {
    double a = *ap;  // 一度だけ読み込み
    double r = *rp;
    for (;;) {
        double prod = a*r;
        if ((0.999999 < prod) && (prod < 1.000001)) {
            break;
        } else {
            r *= (2.0 - prod);
        }
    }
    *rp = r;  // 最後に書き戻し
}

double x = 2.0;
recip(&x, &x);  // 同じ変数のアドレスを渡す！

// 配列の要素を定数倍する関数
void scale_array(const double* src, double* dst, size_t n, double factor) {
    for (size_t i = 0; i < n; i++) {
        dst[i] = src[i] * factor;
    }
}

// コンパイラによる最適化が可能な版（restrictを使用）
void scale_array_opt(const double* restrict src, 
                    double* restrict dst, 
                    size_t n, double factor) {
    // srcとdstが重ならないことが保証されるため、
    // コンパイラはベクトル化などの最適化が可能
    for (size_t i = 0; i < n; i++) {
        dst[i] = src[i] * factor;
    }
}

int a = 10;
int b = 20;
int *p1 = &a;  // p1の由来は変数a
int *p2 = &b;  // p2の由来は変数b

// p1とp2は異なる由来を持つ

void example(int *p, int *q) {
    *p = 10;
    *q = 20;
    // pとqが異なる由来なら、*pは10のまま
    // 同じ由来なら、*pは20になる可能性
    printf("%d\n", *p);
}

int a, b;
int *pa = &a;
int *pb = &b;

// 大小比較の結果は未規定（unspecified）
if (pa < pb) { /* 結果は実装依存 */ }

// 等価比較は定義済み（ただし実装定義の挙動あり）
if (pa == pb) { /* 通常はfalse */ }

int x = 42;
int *p = &x;

// 整数への変換
uintptr_t addr = (uintptr_t)p;  // 露出！[^11]

// printfでの出力
printf("%p\n", p);  // 露出！

// バイト単位でのアクセス
unsigned char *bytes = (unsigned char*)&p;
for (size_t i = 0; i < sizeof(p); i++) {
    printf("%02x", bytes[i]);  // 露出！
}

// 露出→合成
int x = 42;
int *p1 = &x;
uintptr_t addr = (uintptr_t)p1;  // 露出
int *p2 = (int*)addr;             // 合成
*p2 = 100;  // xは100になる

// 任意アドレスの合成は危険
int *p3 = (int*)0x12345678;  // 露出なし
*p3 = 200;  // 未定義動作！

// restrictはエイリアシングしないことの保証
void copy_array(double * restrict dst, 
                const double * restrict src, 
                size_t n) {
    // コンパイラはdstとsrcが異なる由来と仮定可能
    for (size_t i = 0; i < n; i++) {
        dst[i] = src[i];
    }
}

typedef struct elem {
    uintptr_t both;  // prev XOR next を格納
    double data;
} elem;

void elem_store(elem* e, elem* prev, elem* next, double val) {
    e->both = (uintptr_t)prev ^ (uintptr_t)next;
    e->data = val;
}

elem* elem_next(elem const* e, elem* prev) {
    return (elem*)((uintptr_t)prev ^ e->both);
}

// より安全だが、メモリ効率を犠牲にした実装例
// （XORリストの利点であるメモリ節約は失われる）
typedef struct safe_elem {
    unsigned char prev_bytes[sizeof(void*)];
    unsigned char next_bytes[sizeof(void*)];
    double data;
} safe_elem;

void safe_elem_store(safe_elem* e, void* prev, void* next, double val) {
    memcpy(e->prev_bytes, &prev, sizeof(prev));
    memcpy(e->next_bytes, &next, sizeof(next));
    e->data = val;
}

int A[2] = {1, 2};
int B[2] = {3, 4};

// AとBが隣接している可能性
int *end_of_A = &A[2];    // Aの終端
int *start_of_B = &B[0];  // Bの開始

// アドレス値は一致しうるが、由来は異なる

// 両方の記憶域が露出している場合
uintptr_t addr1 = (uintptr_t)&A[0];
uintptr_t addr2 = (uintptr_t)&B[0];

// 境界のアドレスを合成
int *ambiguous = (int*)(addr1 + 2 * sizeof(int));

// 注意：以下のアクセスは未定義動作の可能性あり
// 配列Aの境界を超えたアクセスは、たとえBと隣接していても未定義
ambiguous[-1] = 10;  // 未定義動作！配列境界外へのアクセス
ambiguous[0] = 20;   // Bを指す場合のみ有効（実装定義）

// 避けるべき
void bad_practice(int *p) {
    printf("Debug: pointer = %p\n", p);  // 不要な露出
    uintptr_t addr = (uintptr_t)p;      // 不要な変換
}

// 推奨
void good_practice(int *p) {
    *p = 42;  // 直接使用
}

// エイリアシングしないことを明示
void matrix_multiply(double * restrict result,
                    const double * restrict a,
                    const double * restrict b,
                    size_t n) {
    // 最適化可能
}

// 異なる型のポインタは通常エイリアスしない
void process(float *f, int *i) {
    *f = 3.14;
    *i = 42;
    // コンパイラは*fが3.14のままと仮定可能
}

// Unicode識別子（C23で許可）
double aₚ;  // 下付きp

// ASCII代替名（推奨）
double a_p;  // 互換性のため

// provenanceを意識したコーディング例
typedef struct {
    size_t size;
    int * restrict data;  // エイリアスしないことを明示
} SafeArray;

SafeArray* array_create(size_t n) {
    SafeArray *arr = malloc(sizeof(SafeArray));
    if (!arr) return NULL;
    
    arr->size = n;
    arr->data = malloc(n * sizeof(int));
    if (!arr->data && n > 0) {
        free(arr);
        return NULL;
    }
    
    return arr;
}