レガシー第9章：多重継承の闇と仮想基底クラス（菱形継承）

#include <iostream>

class Entity {
public:
    int id_;
    int hp_;
    Entity(int id, int hp) : id_(id), hp_(hp) {
        std::cout << "Entity コンストラクタ呼び出し (ID: " << id_ << ")\n";
    }
};

class FlyingEnemy : public Entity {
public:
    float flySpeed_;
    FlyingEnemy(int id, int hp, float speed) 
        : Entity(id, hp), flySpeed_(speed) {}
};

class ShootingEnemy : public Entity {
public:
    int ammo_;
    ShootingEnemy(int id, int hp, int ammo) 
        : Entity(id, hp), ammo_(ammo) {}
};

// ❌ 菱形継承
class BossShip : public FlyingEnemy, public ShootingEnemy {
public:
    BossShip(int id, int hp) 
        : FlyingEnemy(id, hp, 5.0f), ShootingEnemy(id, hp, 100) {
        std::cout << "BossShip 生成完了\n";
    }

    void printState() {
        // std::cout << hp_; ➔ コンパイルエラー！
        std::cout << "Flying側のHP: " << FlyingEnemy::hp_ << "\n";
        std::cout << "Shooting側のHP: " << ShootingEnemy::hp_ << "\n";
    }
};

int main() {
    // コンストラクタが2回呼ばれる（Entityが2つ実体化！）
    BossShip boss(999, 500);
    boss.printState();

    std::cout << "BossShipのサイズ: " << sizeof(BossShip) << " バイト\n";
    // Entityのメンバが2重に含まれているためサイズが肥大化！

    return 0;
}

#include <iostream>
#include <iomanip>

class DeviceA {
public:
    int dataA_ = 100;
    virtual void funcA() { std::cout << "DeviceA::funcA\n"; }
};

class DeviceB {
public:
    int dataB_ = 200;
    virtual void funcB() { std::cout << "DeviceB::funcB\n"; }
};

// 2つの基底クラスを多重継承
class CompositeDevice : public DeviceA, public DeviceB {
public:
    int dataComposite_ = 300;
    virtual void funcComposite() { std::cout << "CompositeDevice::funcComposite\n"; }
};

int main() {
    CompositeDevice dev;

    CompositeDevice* pDev = &dev;
    DeviceA* pA = pDev;
    DeviceB* pB = pDev; // 👈 ここでアドレスがズレる！

    std::cout << "=== 多重継承におけるポインタアドレスの実験 ===\n";
    std::cout << "pDev (CompositeDevice*) : " << pDev << "\n";
    std::cout << "pA   (DeviceA*)         : " << pA << " (差分: " << (uintptr_t)pA - (uintptr_t)pDev << " バイト)\n";
    std::cout << "pB   (DeviceB*)         : " << pB << " (差分: +" << (uintptr_t)pB - (uintptr_t)pDev << " バイト)\n";

    // 仮想関数の呼び出しも正常に動作
    pA->funcA();
    pB->funcB(); // CPUは自動調整された正しい this を受け取って実行！

    return 0;
}

#include <iostream>

class Entity {
public:
    int hp_;
    Entity(int hp) : hp_(hp) {
        std::cout << "Entity コンストラクタ: HP=" << hp_ << "\n";
    }
};

// virtual 継承を指定
class FlyingEnemy : virtual public Entity {
public:
    FlyingEnemy(int hp) : Entity(hp) {
        std::cout << "FlyingEnemy コンストラクタ\n";
    }
};

class ShootingEnemy : virtual public Entity {
public:
    ShootingEnemy(int hp) : Entity(hp) {
        std::cout << "ShootingEnemy コンストラクタ\n";
    }
};

// 菱形継承だが、Entity は1つだけ実体化する
class BossShip : public FlyingEnemy, public ShootingEnemy {
public:
    // ⚠️ 最派生クラスが Entity(hp) を直接明示的に初期化しなければならない！
    // FlyingEnemy や ShootingEnemy に書かれた Entity(hp) は完全に無視される！
    BossShip(int hp) 
        : Entity(hp), FlyingEnemy(hp), ShootingEnemy(hp) {
        std::cout << "BossShip コンストラクタ\n";
    }

    void showHp() {
        // 曖昧さなし！直接 hp_ にアクセス可能
        std::cout << "単一に統合されたHP: " << hp_ << "\n";
    }
};

int main() {
    std::cout << "=== 仮想継承の動作実験 ===\n";
    BossShip boss(1000);
    // Entity のコンストラクタは正確に「1回だけ」呼ばれる
    boss.showHp();

    std::cout << "sizeof(BossShip) = " << sizeof(BossShip) << " バイト\n";

    return 0;
}

• 1. C++コンパイラは多重継承を一切サポートしていないため
• 2. ClassC のインスタンス内部に Entity のメンバ変数が2重に実体化してしまい、どちらの変数を指しているか特定できないから
• 3. 多重継承を行うとクラス名が長くなりすぎてコンパイラのメモリが枯渇するから
• 4. ClassA と ClassB のファイル名が異なっているから

• 1. ポインタのアドレス値は全く変化せず、pD と完全に同一のアドレスを指す
• 2. コンパイラが裏でBaseAのサイズ分のオフセットを加算し、BaseBのサブオブジェクトが配置されているアドレスへと自動補正される
• 3. アドレスが 0 (nullptr) にリセットされる
• 4. 実行時エラーが発生して即座にプログラムがクラッシュする

• 1. 基底クラスのコンストラクタは引数を一切取ることができなくなる
• 2. 最派生クラス（末尾のクラス）が、仮想基底クラスのコンストラクタを直接明示的に呼び出す責任を持つ
• 3. 仮想基底クラスのデストラクタを virtual にしてはならない
• 4. すべてのコンストラクタを private にしなければならない

• 1. 合成（has-a）を使うことで、菱形継承の罠やthisポインタ調整の複雑さを完全排除し、振る舞いを部品として柔軟に着脱・テストできるから
• 2. 合成を使うとC++のコンパイル速度が100倍以上高速になるから
• 3. 多重継承を使うとCPUのハードウェアが物理的に故障するリスクがあるから
• 4. モダンC++規格では class キーワードが廃止されたから