レガシー第7章：ポインタ演算と手動メモリアライメントの深淵

### メモリアライメント（境界整列）とは何か？

CPUは物理メモリにアクセスする際、**「自分のワードサイズ（4バイトまたは8バイト）の倍数のアドレス」** から一度にデータを読み出します。

もし `int`（4バイト）が奇数アドレス（例えば `0x1001`）に配置されていた場合、CPUは `0x1000` と `0x1004` の2回メモリを読み出し、それらをビットシフトして結合しなければなりません。これは**大きな性能劣化（ミスアライメントペナルティ）**を引き起こし、ARMなどの組み込みプロセッサでは**アライメント違反例外（SIGBUS）で即座にクラッシュ**します。

そのため、コンパイラは各型のアライメント制約（通常はその型の `sizeof` の倍数）を満たすよう、メンバ間に**パディングバイト（空き領域）**を自動挿入します。

```text
【メモリ上の配置比較】
未最適化構造体：
[ char isAlive (1B) ][ パディング (3B) ][ int score (4B) ][ short level (2B) ][ パディング (2B) ]
合計: 12 バイト！（5バイトも無駄な隙間がある）

宣言順序を最適化した構造体（大きい型から順に並べる）：
[ int score (4B) ][ short level (2B) ][ char isAlive (1B) ][ パディング (1B) ]
合計: 8 バイト！（4バイトもメモリを節約できる！）
```

> [!TIP]
> **構造体設計の鉄則：大きい型のメンバから先に宣言せよ！**
> `double` や `int64_t`（8B）→ `int` や `float`（4B）→ `short`（2B）→ `char` や `bool`（1B）の順に並べるだけで、パディングの発生を最小限に抑えられます。

### ポインタの歩幅（ストライド）とポインタ演算のルール

ポインタに対する加減算は、**「アドレスの数値加算」ではなく「配列の要素インデックス移動」** として定義されています。

```cpp
int arrInt[4];
int* pInt = arrInt;
pInt += 1; // 実際のアドレスは +4 バイト進む（sizeof(int) == 4）

double arrDbl[4];
double* pDbl = arrDbl;
pDbl += 1; // 実際のアドレスは +8 バイト進む（sizeof(double) == 8）

// 生バイト単位で移動したい場合は必ず uint8_t* または char* にキャストする
uint8_t* pByte = reinterpret_cast<uint8_t*>(arrInt);
pByte += 1; // 実際のアドレスが正確に +1 バイト進む
```

### エンディアン（バイト順）の決定的な違い

`uint32_t value = 0x12345678;` をメモリに格納する場合：

| 方式 | アドレス N | アドレス N+1 | アドレス N+2 | アドレス N+3 | 採用例 |
| :--- | :--- | :--- | :--- | :--- | :--- |
| **リトルエンディアン** (下位桁が先) | `0x78` | `0x56` | `0x34` | `0x12` | x86, x64, ARM (PC, iOS, Android) |
| **ビッグエンディアン** (上位桁が先) | `0x12` | `0x34` | `0x56` | `0x78` | TCP/IPネットワーク, PS3(Cell) |

> [!WARNING]
> **Strict Aliasing Rule（厳格な別名規約）の罠とモダンC++20の解決策**
> `char*` や `uint8_t*` 以外の異なる型同士でポインタを相互キャストしてアクセス（例: `*(int*)&myFloat` や `reinterpret_cast<int*>(&myFloat)` による型パンニング）すると、C++規格上の**未定義動作（Undefined Behavior: UB）**となります。コンパイラは「異なる型のポインタは同一メモリ領域を指さない」と仮定して最適化（TBAA: Type-Based Alias Analysis）を行うため、変数の読み書き順序が狂い、Debug版では動くのにReleaseビルドで不可解なバグを生みます。
> - **C++17以前の安全策**: `std::memcpy(&raw, &val, sizeof(float))` を使用する（現代の最適化コンパイラは memcpy 呼出を完全に消去し、レジスタ間の単一移動命令に最適化します）。
> - **C++20以降の究極解**: `<bit>` ヘッダの `std::bit_cast<uint32_t>(val)` を使用する。コンパイル時定数式（`constexpr`）でも評価可能で、未定義動作ゼロかつ完全なゼロオーバーヘッドでビット列を安全に再解釈できます。

#ifndef BINARY_STREAM_H
#define BINARY_STREAM_H

#include <vector>
#include <string>
#include <cstdint>
#include <stdexcept>
#include <cstring>

// 安全なバイナリ書き込みクラス（リトルエンディアン統一）
class BinaryWriter {
private:
    std::vector<uint8_t> m_buffer;

public:
    BinaryWriter() {}

    // 1バイト書き込み
    void writeUint8(uint8_t val) {
        m_buffer.push_back(val);
    }

    // 16bit整数書き込み（リトルエンディアン）
    void writeUint16(uint16_t val) {
        m_buffer.push_back(static_cast<uint8_t>(val & 0xFF));
        m_buffer.push_back(static_cast<uint8_t>((val >> 8) & 0xFF));
    }

    // 32bit整数書き込み（リトルエンディアン）
    void writeUint32(uint32_t val) {
        m_buffer.push_back(static_cast<uint8_t>(val & 0xFF));
        m_buffer.push_back(static_cast<uint8_t>((val >> 8) & 0xFF));
        m_buffer.push_back(static_cast<uint8_t>((val >> 16) & 0xFF));
        m_buffer.push_back(static_cast<uint8_t>((val >> 24) & 0xFF));
    }

    // float (32bit浮動小数点) 書き込み (memcpyでエイリアシングルール遵守)
    void writeFloat(float val) {
        uint32_t raw;
        std::memcpy(&raw, &val, sizeof(float));
        writeUint32(raw);
    }

    // 文字列書き込み (長さ uint16 + 文字列バイト列)
    void writeString(const std::string& str) {
        writeUint16(static_cast<uint16_t>(str.size()));
        for (char c : str) {
            writeUint8(static_cast<uint8_t>(c));
        }
    }

    // 完成したバッファ参照
    const std::vector<uint8_t>& getBuffer() const { return m_buffer; }
    size_t getSize() const { return m_buffer.size(); }
};

// 安全なバイナリ読み出しクラス
class BinaryReader {
private:
    const uint8_t* m_data;
    size_t m_size;
    size_t m_cursor;

public:
    BinaryReader(const uint8_t* data, size_t size)
        : m_data(data), m_size(size), m_cursor(0) {}

    bool hasRemaining(size_t bytes) const {
        return m_cursor + bytes <= m_size;
    }

    uint8_t readUint8() {
        if (!hasRemaining(1)) throw std::runtime_error("Unexpected End of Stream");
        return m_data[m_cursor++];
    }

    uint16_t readUint16() {
        if (!hasRemaining(2)) throw std::runtime_error("Unexpected End of Stream");
        uint16_t b0 = m_data[m_cursor++];
        uint16_t b1 = m_data[m_cursor++];
        return static_cast<uint16_t>(b0 | (b1 << 8));
    }

    uint32_t readUint32() {
        if (!hasRemaining(4)) throw std::runtime_error("Unexpected End of Stream");
        uint32_t b0 = m_data[m_cursor++];
        uint32_t b1 = m_data[m_cursor++];
        uint32_t b2 = m_data[m_cursor++];
        uint32_t b3 = m_data[m_cursor++];
        return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
    }

    float readFloat() {
        uint32_t raw = readUint32();
        float val;
        std::memcpy(&val, &raw, sizeof(float));
        return val;
    }

    std::string readString() {
        uint16_t len = readUint16();
        if (!hasRemaining(len)) throw std::runtime_error("Unexpected End of Stream in String");
        std::string str(reinterpret_cast<const char*>(m_data + m_cursor), len);
        m_cursor += len;
        return str;
    }
};

#endif // BINARY_STREAM_H

#ifndef SAVE_DATA_PACKET_H
#define SAVE_DATA_PACKET_H

#include "BinaryStream.h"
#include <string>

// 自機のセーブデータ構造体
struct PlayerSaveState {
    std::string playerName; // プレイヤー名
    float       posX;       // X座標
    float       posY;       // Y座標
    uint32_t    score;      // ハイスコア
    uint16_t    hp;         // 残り体力
    uint8_t     weaponLevel;// 武器レベル
};

// ヘッダ付きセーブデータパケット管理クラス
class SaveDataPacket {
public:
    static const uint32_t MAGIC_HEADER = 0x4D524B53; // "SKRM" (リトルエンディアン)
    static const uint16_t CURRENT_VERSION = 1;

    // セーブデータをバイナリバッファにシリアライズ
    static std::vector<uint8_t> serialize(const PlayerSaveState& player) {
        BinaryWriter writer;

        // 1. ヘッダ情報 (マジックナンバー + バージョン)
        writer.writeUint32(MAGIC_HEADER);
        writer.writeUint16(CURRENT_VERSION);

        // 2. プレイヤーデータ本体
        writer.writeString(player.playerName);
        writer.writeFloat(player.posX);
        writer.writeFloat(player.posY);
        writer.writeUint32(player.score);
        writer.writeUint16(player.hp);
        writer.writeUint8(player.weaponLevel);

        return writer.getBuffer();
    }

    // バイナリバッファからセーブデータを安全にデシリアライズ
    static bool deserialize(const uint8_t* data, size_t size, PlayerSaveState& outPlayer) {
        try {
            BinaryReader reader(data, size);

            // 1. マジックナンバー検証
            uint32_t magic = reader.readUint32();
            if (magic != MAGIC_HEADER) {
                return false; // 不正なファイルフォーマット
            }

            // 2. バージョン確認
            uint16_t version = reader.readUint16();
            if (version != CURRENT_VERSION) {
                return false; // 未対応バージョン
            }

            // 3. データ復元
            outPlayer.playerName  = reader.readString();
            outPlayer.posX        = reader.readFloat();
            outPlayer.posY        = reader.readFloat();
            outPlayer.score       = reader.readUint32();
            outPlayer.hp          = reader.readUint16();
            outPlayer.weaponLevel = reader.readUint8();

            return true;
        } catch (...) {
            return false; // データ破損
        }
    }
};

#endif // SAVE_DATA_PACKET_H

#include <iostream>
#include <iomanip>
#include "SaveDataPacket.h"

void dumpHex(const std::vector<uint8_t>& buf) {
    std::cout << "[バイナリダンプ (" << buf.size() << " bytes)]:" << std::endl;
    for (size_t i = 0; i < buf.size(); ++i) {
        std::cout << std::hex << std::setw(2) << std::setfill('0')
                  << static_cast<int>(buf[i]) << " ";
        if ((i + 1) % 8 == 0) std::cout << " ";
        if ((i + 1) % 16 == 0) std::cout << std::endl;
    }
    std::cout << std::dec << std::endl;
}

int main() {
    std::cout << "=== シロクマC++ラボ L7: バイナリシリアライズ実証 ===" << std::endl;

    // 1. セーブするプレイヤーデータ作成
    PlayerSaveState original;
    original.playerName  = "ShirokumaAce";
    original.posX        = 128.5f;
    original.posY        = 256.0f;
    original.score       = 987654;
    original.hp          = 100;
    original.weaponLevel = 3;

    // 2. シリアライズ実行（バイト列化）
    std::vector<uint8_t> binaryData = SaveDataPacket::serialize(original);
    dumpHex(binaryData);

    // 3. デシリアライズ実行（復元）
    PlayerSaveState loaded;
    bool success = SaveDataPacket::deserialize(binaryData.data(), binaryData.size(), loaded);

    if (success) {
        std::cout << "✅ セーブデータの復元に成功しました！" << std::endl;
        std::cout << "  プレイヤー名: " << loaded.playerName << std::endl;
        std::cout << "  座標 (X, Y) : (" << loaded.posX << ", " << loaded.posY << ")" << std::endl;
        std::cout << "  スコア      : " << loaded.score << std::endl;
        std::cout << "  残りHP      : " << loaded.hp << std::endl;
        std::cout << "  武器レベル  : " << static_cast<int>(loaded.weaponLevel) << std::endl;
    } else {
        std::cout << "❌ データ破損または無効なヘッダです。" << std::endl;
    }

    return 0;
}

• 1. 1 + 8 + 2 = 11バイト（パディングなし）
• 2. 16バイト（aの後ろに7バイトパディング、末尾パディングなし）
• 3. 24バイト（aの後ろに7バイト、cの後ろに6バイトのパディングが挿入される）
• 4. 32バイト（すべてのメンバが8バイト単位に拡張される）

正解と解説を見る

正解：24バイト（aの後ろに7バイト、cの後ろに6バイトのパディングが挿入される）
正解は 24バイト です。double のアライメント制約（8バイト境界）を満たすため、char a の直後に 7バイトのパディングが挿入されます。さらに、構造体の配列を作成した際に次の要素の double が正しく8バイト境界に並ぶよう、末尾の short c（2B）の後ろにも 6バイトのパディングが挿入され、全体サイズが最大の型アライメント（8B）の倍数である 24バイト に揃えられます。

• 1. struct Data { char a; short c; double b; };
• 2. struct Data { double b; short c; char a; };
• 3. struct Data { short c; double b; char a; };
• 4. 宣言順序を変えてもパディングは変わらない

正解と解説を見る

正解：struct Data { double b; short c; char a; };
正解は「struct Data { double b; short c; char a; };」です。大きい型から順に並べると、double b (8B) ＋ short c (2B) ＋ char a (1B) となり、有効データは 11バイト。8バイト境界に揃えるための末尾パディングは 5バイトのみとなり、合計 16バイト に縮小できます（24バイトから8バイトも節約可能）。

• 1. 0x12, 0x34, 0x56, 0x78
• 2. 0x78, 0x56, 0x34, 0x12
• 3. 0x56, 0x78, 0x12, 0x34
• 4. 0x78, 0x12, 0x56, 0x34

正解と解説を見る

正解：0x78, 0x56, 0x34, 0x12
正解は「0x78, 0x56, 0x34, 0x12」です。リトルエンディアン（Little Endian）では、数値の最下位バイト（Least Significant Byte: 0x78）が最も小さいアドレス（先頭）に配置され、最上位バイト（0x12）が末尾アドレスに配置されます。

• 1. fwrite 関数はテキストファイル専用であり、バイナリを書き込めないから
• 2. コンパイラやOSによってパディングサイズやエンディアンが異なり、他の環境でデータが破損・化けるから
• 3. 構造体の中にポインタが1つでも含まれているとコンパイルエラーになるから
• 4. C++ではファイル入出力に std::cout しか使えない仕様になっているから

正解と解説を見る

正解：コンパイラやOSによってパディングサイズやエンディアンが異なり、他の環境でデータが破損・化けるから
正解は「コンパイラやOSによってパディングサイズやエンディアンが異なり、他の環境でデータが破損・化けるから」です。コンパイラバージョンや32bit/64bit環境の違い、CPUエンディアンの違いにより、生メモリのダンプデータは互換性が破壊されます。現場では本章で作成した BinaryWriter のように明示的にバイト列へパッキングして保存・送信するのが鉄則です。