C++の仮想関数とオーバーライドとは？動的バインディング入門

#include <iostream>

// 基底クラス（親クラス）
class Animal 
{
public:
    // 仮想関数として定義
    virtual void makeSound() 
    {
        std::cout << "何かの音を出す" << std::endl;
    }
    
    // 仮想デストラクタも重要
    virtual ~Animal() = default;
};

// 派生クラス（子クラス）
class Dog : public Animal 
{
public:
    // オーバーライドして具体的な実装を提供
    void makeSound() override 
    {
        std::cout << "ワンワン！" << std::endl;
    }
};

class Cat : public Animal 
{
public:
    void makeSound() override 
    {
        std::cout << "ニャー" << std::endl;
    }
};

class Bird : public Animal 
{
public:
    // overrideキーワードを付けることで安全性が向上
    void makeSound() override 
    {
        std::cout << "チュンチュン" << std::endl;
    }
    
    // もしタイプミスがあった場合、コンパイルエラーになる
    // void makesound() override; // エラー！元の関数と名前が違う
};

// 基底クラス：ゲームキャラクター
class GameCharacter 
{
protected:
    std::string name;
    int health;
    int attackPower;

public:
    GameCharacter(const std::string& n, int hp, int attack) 
        : name(n), health(hp), attackPower(attack) {}
    
    // 仮想関数：攻撃アクション
    virtual void attack() 
    {
        std::cout << name << " が基本攻撃をした！" << std::endl;
    }
    
    // 仮想関数：特殊スキル
    virtual void useSpecialSkill() 
    {
        std::cout << name << " が特殊スキルを使った！" << std::endl;
    }
    
    // ゲッター関数
    const std::string& getName() const { return name; }
    
    virtual ~GameCharacter() = default;
};

// 戦士クラス
class Warrior : public GameCharacter 
{
public:
    Warrior(const std::string& name) 
        : GameCharacter(name, 150, 25) {}
    
    void attack() override 
    {
        std::cout << name << " が剣で斬りつけた！ダメージ: " 
                  << attackPower << std::endl;
    }
    
    void useSpecialSkill() override 
    {
        std::cout << name << " が「必殺剣技」を発動！ダメージ: " 
                  << attackPower * 2 << std::endl;
    }
};

// 魔法使いクラス
class Mage : public GameCharacter 
{
public:
    Mage(const std::string& name) 
        : GameCharacter(name, 80, 35) {}
    
    void attack() override 
    {
        std::cout << name << " が魔法の矢を放った！ダメージ: " 
                  << attackPower << std::endl;
    }
    
    void useSpecialSkill() override 
    {
        std::cout << name << " が「ファイアボール」を詠唱！ダメージ: " 
                  << attackPower * 3 << std::endl;
    }
};

int main() 
{
    // 異なる型のキャラクターを同じ配列で管理
    std::vector<std::unique_ptr<GameCharacter>> party;
    
    party.push_back(std::make_unique<Warrior>("アーサー"));
    party.push_back(std::make_unique<Mage>("マーリン"));
    party.push_back(std::make_unique<Warrior>("ランスロット"));
    
    std::cout << "=== パーティ全員で攻撃！ ===" << std::endl;
    for (auto& character : party) 
    {
        // 同じメソッド呼び出しでも、実際の型に応じて
        // 異なる動作をする（動的バインディング）
        character->attack();
    }
    
    std::cout << "\n=== 特殊スキル発動！ ===" << std::endl;
    for (auto& character : party) 
    {
        character->useSpecialSkill();
    }
    
    return 0;
}

class Base 
{
public:
    // 重要：デストラクタを仮想にする
    virtual ~Base() = default;
};

class Derived : public Base 
{
private:
    int* data;
    
public:
    Derived() : data(new int[100]) {}
    
    // このデストラクタが正しく呼ばれるために
    // 基底クラスのデストラクタが仮想である必要がある
    ~Derived() 
    {
        delete[] data;
    }
};

class Shape 
{
public:
    // 純粋仮想関数（= 0 で定義）
    virtual double getArea() const = 0;
    virtual void draw() const = 0;
    
    virtual ~Shape() = default;
};

class Circle : public Shape 
{
private:
    double radius;
    
public:
    Circle(double r) : radius(r) {}
    
    // 純粋仮想関数は必ずオーバーライドが必要
    double getArea() const override 
    {
        return 3.14159 * radius * radius;
    }
    
    void draw() const override 
    {
        std::cout << "円を描画します（半径: " << radius << "）" << std::endl;
    }
};