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

C++

オブジェクト指向

最終更新2025年7月3日

リンドくん

たなべ先生、C++の仮想関数って何ですか？難しそうで手が出せません...

たなべ

確かに最初は難しく感じるかもしれないね。
これはゲームのキャラクターが同じ「攻撃」コマンドでも違う攻撃をするのと同じ仕組みなんだよ。

C++を学び始めた方にとって、仮想関数（virtual function）とオーバーライド（override）は理解が難しい概念の一つではないでしょうか？
しかし、これらは現代のソフトウェア開発において非常に重要な技術です。

特に、ゲーム開発やWebアプリケーション開発では、同じインターフェースで異なる動作を実現する「ポリモーフィズム」の概念が頻繁に使われています。
この記事では、仮想関数の基本から実践的な活用方法まで、初心者の方でも理解できるよう段階的に解説していきます。

プログラミング学習でお悩みの方へ

HackATAは、エンジニアを目指す方のためのプログラミング学習コーチングサービスです。経験豊富な現役エンジニアがあなたの学習をサポートします。

✓ 質問し放題

✓ β版公開中（2025年内の特別割引）

HackATAの詳細を見る

仮想関数とは何か？基本概念をわかりやすく解説

リンドくん

そもそも「仮想」って何が仮想なんですか？

たなべ

いい質問だね！「仮想」は「実際の処理は子クラスで決まる」という意味なんだ。
親クラスでは「こんな機能があるよ」と宣言だけして、実際の中身は子クラスに任せるイメージだよ。

仮想関数の基本的な考え方

仮想関数とは、基底クラス（親クラス）で定義され、派生クラス（子クラス）で再定義（オーバーライド）することができる関数のことです。
重要なのは、実行時にどの関数が呼ばれるかが決まるという点です。

これを理解するために、日常的な例で考えてみましょう。「動物」という概念があって、すべての動物は「鳴く」という行動ができるとします。
しかし、犬は「ワンワン」、猫は「ニャー」と、それぞれ異なる鳴き方をしますよね。

プログラミングでは、この「鳴く」という共通の行動を仮想関数として定義し、各動物（派生クラス）で具体的な鳴き方を実装します。

動的バインディングとは

仮想関数を理解する上で重要なのが動的バインディングという概念です。
これはプログラム実行時に実際のオブジェクトの型に基づいて呼び出す関数を決定する仕組みのことです。

通常の関数呼び出し（静的バインディング）では、コンパイル時にどの関数を呼ぶかが決まります。
しかし、仮想関数を使うと、実際にプログラムが動いているときに「このオブジェクトは犬だから犬の鳴き方を使おう」という判断が行われるのです。

この仕組みにより、同じコードで異なる動作を実現できるため、プログラムの柔軟性と拡張性が大幅に向上します。

基本的な仮想関数の実装方法

シンプルな仮想関数の例

まず、最もシンプルな仮想関数の実装を見てみましょう。

#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;
    }
};

overrideキーワードの重要性

C++11以降では、overrideキーワードを使用することが強く推奨されています。
これにより以下のメリットが得られます。

コンパイラが正しくオーバーライドされているかチェックしてくれる
コードの意図が明確になる
タイプミスや関数シグネチャの間違いを防げる

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;
}

このコードの素晴らしい点は、同じループ処理で異なる型のオブジェクトを扱えることです。
新しいキャラクタークラス（例: 盗賊、僧侶など）を追加しても、このメインの処理は変更する必要がありません。

仮想関数の注意点とベストプラクティス

パフォーマンスへの影響

仮想関数は非常に便利ですが、いくつかの注意点があります。

パフォーマンスのオーバーヘッド → 仮想関数はvtable（仮想関数テーブル）という仕組みを使用するため、通常の関数呼び出しより若干のオーバーヘッドがあります。しかし、現代のコンピュータでは、このオーバーヘッドは多くの場合無視できる程度です。

仮想デストラクタの重要性

仮想デストラクタは必須です。
基底クラスのデストラクタを仮想にしないと、正しく派生クラスのデストラクタが呼ばれず、メモリリークの原因となる可能性があります。

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;
    }
};