レガシー第10章：静的ポリモーフィズム入門（CRTPとクラシックTemplate）

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

// 1. 動的ポリモーフィズム (仮想関数)
class IVirtualParticle {
public:
    virtual ~IVirtualParticle() = default;
    virtual void update() = 0;
};

class VirtualSpark : public IVirtualParticle {
public:
    float x = 0, y = 0, vx = 1.5f, vy = 2.0f;
    void update() override {
        x += vx;
        y += vy;
    }
};

int main() {
    const int COUNT = 100000;
    std::vector<IVirtualParticle*> particles;
    for (int i = 0; i < COUNT; ++i) {
        particles.push_back(new VirtualSpark());
    }

    auto start = std::chrono::high_resolution_clock::now();

    // 10万個の仮想関数呼び出しループ
    for (int frame = 0; frame < 100; ++frame) {
        for (int i = 0; i < COUNT; ++i) {
            particles[i]->update(); // vptr 間接呼び出し（インライン展開不可）
        }
    }

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> elapsed = end - start;

    std::cout << "仮想関数 10万個 x 100フレーム 更新時間: " 
              << elapsed.count() << " ms\n";
    std::cout << "1個あたりのサイズ: " << sizeof(VirtualSpark) << " バイト (vptr含む)\n";

    // メモリ解放
    for (auto* p : particles) delete p;

    return 0;
}

#include <iostream>

// CRTP基底クラス
template <typename Derived>
class SpaceObject {
public:
    // 共通インターフェース
    void render() {
        // 派生クラスの具象実装をコンパイル時ディスパッチ
        static_cast<Derived*>(this)->renderImpl();
    }

    void move() {
        static_cast<Derived*>(this)->moveImpl();
    }
};

// 派生クラス1: 通常弾
class LaserBeam : public SpaceObject<LaserBeam> {
public:
    void renderImpl() {
        std::cout << "━ レーザー描画 (シアン色)\n";
    }
    void moveImpl() {
        std::cout << "レーザー光速直進\n";
    }
};

// 派生クラス2: 誘導ミサイル
class HomingMissile : public SpaceObject<HomingMissile> {
public:
    void renderImpl() {
        std::cout << "▲ ミサイル描画 (オレンジ色)\n";
    }
    void moveImpl() {
        std::cout << "ミサイル追尾旋回\n";
    }
};

// テンプレート関数による統一呼び出し
template <typename T>
void processObject(SpaceObject<T>& obj) {
    obj.move();
    obj.render();
}

int main() {
    LaserBeam laser;
    HomingMissile missile;

    std::cout << "=== CRTP 静的ポリモーフィズム実行 ===\n";
    processObject(laser);
    processObject(missile);

    std::cout << "\n=== オブジェクトサイズの比較 ===\n";
    std::cout << "LaserBeam のサイズ: " << sizeof(laser) << " バイト\n";
    std::cout << "HomingMissile のサイズ: " << sizeof(missile) << " バイト\n";
    // 仮想関数が一切ないため、vptr の 8バイトが存在しない！

    return 0;
}

#include <iostream>
#include <vector>

// 1. 生存数カウンタ Mix-in (CRTP)
template <typename T>
class ObjectCounter {
private:
    static inline int activeCount_ = 0;
public:
    ObjectCounter() { ++activeCount_; }
    ObjectCounter(const ObjectCounter&) { ++activeCount_; }
    virtual ~ObjectCounter() = default; // 安全のための仮想デストラクタ
    // 注: Mix-in単体としてデストラクタが必要な場合のみ
    static int getActiveCount() { return activeCount_; }
protected:
    void decrement() { --activeCount_; }
};

// 2. 弾幕CRTP基底クラス
template <typename Derived>
class BulletSystem {
public:
    void updatePhysics(float dt) {
        static_cast<Derived*>(this)->onUpdate(dt);
    }
};

// 3. 具体的な弾1: 直進レーザー
class Laser : public BulletSystem<Laser>, public ObjectCounter<Laser> {
public:
    float x = 0, y = 0, speed = 800.0f;

    void onUpdate(float dt) {
        y += speed * dt; // インライン展開される超高速移動
    }
};

// 4. 具体的な弾2: 拡散弾
class SpreadPellet : public BulletSystem<SpreadPellet>, public ObjectCounter<SpreadPellet> {
public:
    float x = 0, y = 0, vx = 200.0f, vy = 300.0f;

    void onUpdate(float dt) {
        x += vx * dt;
        y += vy * dt;
    }
};

// 5. 弾幕マネージャー (型ごとの高密度連続配列)
class BulletManager {
private:
    std::vector<Laser> lasers_;
    std::vector<SpreadPellet> pellets_;

public:
    void spawnLaser(float startX, float startY) {
        Laser l; l.x = startX; l.y = startY;
        lasers_.push_back(l);
    }

    void spawnPellet(float startX, float startY, float vx, float vy) {
        SpreadPellet p; p.x = startX; p.y = startY; p.vx = vx; p.vy = vy;
        pellets_.push_back(p);
    }

    void updateAll(float dt) {
        // レーザーの超高速一括更新 (CRTPにより完全インライン化)
        for (auto& laser : lasers_) {
            laser.updatePhysics(dt);
        }

        // 拡散弾の超高速一括更新 (CRTPにより完全インライン化)
        for (auto& pellet : pellets_) {
            pellet.updatePhysics(dt);
        }
    }

    void printStats() const {
        std::cout << "アクティブなレーザー数: " << Laser::getActiveCount() << "\n";
        std::cout << "アクティブな拡散弾数:   " << SpreadPellet::getActiveCount() << "\n";
    }
};

int main() {
    BulletManager manager;

    // 弾を生成
    for (int i = 0; i < 5; ++i) manager.spawnLaser(i * 50.0f, 100.0f);
    for (int i = 0; i < 8; ++i) manager.spawnPellet(200.0f, 200.0f, (i - 4) * 30.0f, 150.0f);

    std::cout << "=== 弾幕エンジンのシミュレーション ===\n";
    manager.printStats();

    // 1フレーム更新 (60FPS相当: dt = 0.016s)
    manager.updateAll(0.016f);
    std::cout << "1フレーム更新完了（関数呼び出しコストゼロ・完全インライン実行）\n";

    return 0;
}

• 1. 仮想関数を宣言するとコンパイラが自動的に sleep(1) を挿入する仕様だから
• 2. vtable を介したポインタ間接参照が発生し、呼び出し先が実行時まで確定しないためコンパイラが「インライン展開（Inlining）」を行えず関数呼び出しオーバーヘッドが毎回発生するから
• 3. C++の仮想関数は1つのクラスで最大10回しか呼び出せない制限があるから
• 4. 仮想関数を使うとCPUの冷却ファンが停止してしまうから

• 1. C++ではすべてのポインタキャストが無条件で安全に実行されるから
• 2. 基底クラスのメンバ関数が実際にインスタンス化（コンパイル）される時点では、派生クラス Bullet の完全な定義が完了しており、Bullet が BulletBase<Bullet> の派生クラスであることが保証されているから
• 3. コンパイラが裏で dynamic_cast を実行して安全性を検証しているから
• 4. 派生クラスが仮想関数テーブルを自動生成するから

• 1. CRTPを使うとコードの実行速度が100倍遅くなる
• 2. 異なる派生クラス（例: Bullet と Laser）は基底テンプレートの型（Base<Bullet> と Base<Laser>）が異なるため、std::vector<Base*> のような単一の異種混合コンテナにまとめて保持することができない点
• 3. CRTPを使ったクラスにはメンバ変数を定義できない
• 4. 64bit OSではCRTPがコンパイルエラーになる

• 1. すべてのコードをCRTPだけで書き、仮想関数は一切使わないようにする
• 2. 画面遷移（Title/Play/GameOver）など疎結合性と動的な差し替えが重要な高位レイヤーには仮想関数を使い、弾幕・パーティクル・物理剛体など毎フレーム大量に処理されるコア層にはCRTPやデータ指向配列を使う
• 3. すべてのコードを仮想関数だけで書き、テンプレートは一切使わないようにする
• 4. 偶数日には仮想関数を使い、奇数日にはCRTPを使う