レガシー第11章：独自メモリアロケータと固定長プール管理

#include <iostream>
#include <vector>
#include <chrono>

// 弾オブジェクト（48バイト）
struct Bullet {
    float x, y;
    float vx, vy;
    int damage;
    int lifeTimer;
    char padding[24]; // リアルなサイズをシミュレート
};

// ❌ 悪い例：毎フレームのヒープ確保とランダム破棄（断片化の再現）
void benchmarkHeap() {
    auto start = std::chrono::high_resolution_clock::now();
    std::vector<Bullet*> activeBullets;
    activeBullets.reserve(10000);

    for (int frame = 0; frame < 10000; ++frame) {
        // 毎フレーム10個生成
        for (int i = 0; i < 10; ++i) {
            activeBullets.push_back(new Bullet{0, 0, 1, 1, 10, 60, {}});
        }
        // 古い弾を途中で間引き削除（虫食いを作る）
        if (activeBullets.size() > 500) {
            for (int i = 0; i < 5; ++i) {
                delete activeBullets[i];
            }
            activeBullets.erase(activeBullets.begin(), activeBullets.begin() + 5);
        }
    }

    for (auto* b : activeBullets) delete b;
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Heap new/delete time: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() 
              << " ms\n";
}

#pragma once
#include <cstddef>
#include <new>
#include <utility>
#include <cassert>

template <typename T, size_t Capacity>
class FixedMemoryPool {
private:
    // スロットの共用体（Union）：
    // 貸出中は T の生メモリ領域として機能し、
    // 空き状態の時は次の空きノードへのポインタとして機能する！
    union Slot {
        alignas(alignof(T)) char storage[sizeof(T)];
        Slot* next; // 空きリスト連結用ポインタ
    };

    Slot m_pool[Capacity]; // 連続した巨大メモリブロック
    Slot* m_freeListHead;  // 次に貸し出せる空きスロットの先頭
    size_t m_allocatedCount;

public:
    FixedMemoryPool() : m_freeListHead(nullptr), m_allocatedCount(0) {
        // 全スロットを芋づる式にフリーリストへ繋ぐ
        for (size_t i = 0; i < Capacity - 1; ++i) {
            m_pool[i].next = &m_pool[i + 1];
        }
        m_pool[Capacity - 1].next = nullptr;
        m_freeListHead = &m_pool[0];
    }

    // O(1) でメモリを割り当て、コンストラクタを呼び出す
    template <typename... Args>
    T* allocate(Args&&... args) {
        if (!m_freeListHead) {
            return nullptr; // プール枯渇！
        }

        // 1. フリーリストの先頭を取り出す
        Slot* slot = m_freeListHead;
        m_freeListHead = m_freeListHead->next;
        ++m_allocatedCount;

        // 2. プレースメント new でそのアドレス上に T を直接構築！
        return new (slot->storage) T(std::forward<Args>(args)...);
    }

    // O(1) でデストラクタを呼び出し、メモリをプールへ返却
    void deallocate(T* ptr) {
        if (!ptr) return;

        // 1. 明示的デストラクタ呼び出し（メモリは解放しない！）
        ptr->~T();

        // 2. スロットをフリーリストの先頭へ差し戻す
        Slot* slot = reinterpret_cast<Slot*>(ptr);
        slot->next = m_freeListHead;
        m_freeListHead = slot;
        --m_allocatedCount;
    }

    size_t allocatedCount() const { return m_allocatedCount; }
    size_t capacity() const { return Capacity; }
    bool isFull() const { return m_freeListHead == nullptr; }
};

#include <iostream>
#include <new> // プレースメント new のために必須

class ExplosionParticle {
private:
    int m_id;
public:
    ExplosionParticle(int id) : m_id(id) {
        std::cout << "Particle [" << m_id << "] 誕生（コンストラクタ実行）\n";
    }
    ~ExplosionParticle() {
        std::cout << "Particle [" << m_id << "] 爆散終了（デストラクタ実行）\n";
    }
    void render() {
        std::cout << "Particle [" << m_id << "] 描画中...\n";
    }
};

int main() {
    // 1. スタック上に生メモリ領域をアライメント考慮で用意
    alignas(ExplosionParticle) char rawMemory[sizeof(ExplosionParticle)];

    std::cout << "--- 1. プレースメント new で生メモリ上に直接インスタンス化 ---\n";
    // メモリ確保は行わず、rawMemory の位置にオブジェクトを構築する
    ExplosionParticle* p = new (rawMemory) ExplosionParticle(42);
    p->render();

    std::cout << "\n--- 2. 明示的デストラクタ呼び出し ---\n";
    // メモリ解放は行わず、後片付け処理（デストラクタ）のみを実行！
    // ❌ 絶対に delete p; を呼んではならない（rawMemory はスタックなので即死）
    p->~ExplosionParticle();

    std::cout << "\n--- 3. 同じ生メモリ領域に別のオブジェクトを再構築！ ---\n";
    ExplosionParticle* p2 = new (rawMemory) ExplosionParticle(99);
    p2->render();
    p2->~ExplosionParticle();

    return 0;
}

#pragma once
#include "FixedMemoryPool.hpp"
#include <vector>
#include <iostream>

struct Bullet {
    float x, y;
    float vy;
    bool isAlive;

    Bullet(float startX, float startY, float speedY)
        : x(startX), y(startY), vy(speedY), isAlive(true) {}

    void update() {
        y += vy;
        if (y < 0.0f || y > 600.0f) {
            isAlive = false; // 画面外で死亡
        }
    }
};

class GameBulletManager {
private:
    // 最大1024発の弾を事前一括確保するプール
    FixedMemoryPool<Bullet, 1024> m_pool;
    // 画面上で現在アクティブな弾のポインタリスト
    std::vector<Bullet*> m_activeBullets;

public:
    void spawnBullet(float x, float y, float vy) {
        Bullet* b = m_pool.allocate(x, y, vy);
        if (b) {
            m_activeBullets.push_back(b);
        } else {
            std::cerr << "警告: 弾丸プール枯渇！発射をスキップ\n";
        }
    }

    void updateAll() {
        for (size_t i = 0; i < m_activeBullets.size(); ) {
            Bullet* b = m_activeBullets[i];
            b->update();

            if (!b->isAlive) {
                // 1. プールへ返却（O(1)）
                m_pool.deallocate(b);

                // 2. vector の末尾と入れ替えて高速削除（swap-and-pop: O(1)）
                m_activeBullets[i] = m_activeBullets.back();
                m_activeBullets.pop_back();
            } else {
                ++i;
            }
        }
    }

    size_t activeCount() const { return m_activeBullets.size(); }
    size_t poolUsage() const { return m_pool.allocatedCount(); }
};

• 1. C++コンパイラが new を見つけると自動的に最適化を解除してしまう仕様だから
• 2. OSのヒープアロケータは実行時間がブレる（非決定論的）上に、断片化（フラグメンテーション）により空き容量があっても割り当て不能でクラッシュする危険があるから
• 3. new で確保したメモリは delete を呼んでもOSに返却されないバグがCPUに存在するから
• 4. ポインタのビット数が new を呼ぶたびに肥大化して64bitを超えてしまうから

• 1. プレースメント new はヒープから自動確保するため、通常通り delete ptr; で破棄しなければならない
• 2. プレースメント new はメモリ確保を行わず指定アドレスにオブジェクトを構築するため、破棄時は delete を使わず明示的デストラクタ（ptr->~T()）を呼び、メモリはプールへ返却する
• 3. プレースメント new で構築したオブジェクトはデストラクタを呼び出す必要がなく、free(ptr) だけで完全に安全に破棄できる
• 4. プレースメント new は C++17 で非推奨となり、現在は std::make_shared 以外の使用が禁止されている