MENU
  1. ホーム
  2. C++
  3. C++仮想関数を使ったイベントハンドリングシステムの実装方法

C++仮想関数を使ったイベントハンドリングシステムの実装方法

C++

イベントハンドリングシステムは、GUIアプリケーションやゲーム開発などで頻繁に使用される重要なコンポーネントです。C++では、仮想関数を利用することで柔軟で拡張性の高いイベントハンドリングシステムを構築することが可能です。本記事では、C++の仮想関数を用いたイベントハンドリングシステムの基本的な概念から具体的な実装方法までを詳細に解説し、さらに応用例や演習問題を通じて理解を深めることを目的とします。まずは、イベントハンドリングシステムの基本概念から始めましょう。

目次

イベントハンドリングシステムの基本概念

イベントハンドリングシステムは、ユーザーやプログラムの操作に対して特定の処理を実行する仕組みです。このシステムは、特定の「イベント」が発生した際に、そのイベントに対応する「イベントハンドラー」が呼び出されることで機能します。イベントハンドリングシステムは、以下のような基本的な構成要素から成り立っています。

イベント

イベントとは、特定の操作や状態変化を指します。例えば、ボタンのクリックやキーの押下、ウィンドウのリサイズなどがイベントとして扱われます。

イベントハンドラー

イベントハンドラーは、特定のイベントが発生したときに実行される関数やメソッドです。イベントハンドラーは、イベントに対する具体的な処理を実装します。

イベントディスパッチャ

イベントディスパッチャは、発生したイベントを適切なイベントハンドラーに振り分ける役割を担います。ディスパッチャは、イベントとハンドラーの関連付けを管理し、イベントが発生した際に対応するハンドラーを呼び出します。

これらの基本概念を理解することで、C++でのイベントハンドリングシステムの実装がより明確になります。次に、仮想関数の基礎知識について解説します。

仮想関数の基礎知識

仮想関数は、C++のポリモーフィズム（多態性）を実現するための重要な機能です。仮想関数を利用することで、基底クラスのポインタや参照を用いて、派生クラスのオーバーライドされたメソッドを呼び出すことができます。これにより、柔軟で拡張性の高いコードを実現できます。

仮想関数の定義と使用方法

仮想関数は、基底クラスでvirtualキーワードを使用して宣言されます。派生クラスで同じ関数をオーバーライドすることで、基底クラスのポインタや参照を通じて派生クラスの関数を呼び出せます。以下は、基本的な仮想関数の定義例です。

class Base {
public:
    virtual void show() {
        std::cout << "Base class show function." << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        std::cout << "Derived class show function." << std::endl;
    }
};

int main() {
    Base* basePtr;
    Derived derivedObj;
    basePtr = &derivedObj;
    basePtr->show(); // Outputs: "Derived class show function."
    return 0;
}

仮想関数テーブル（VTable）

仮想関数は、実行時に適切な関数を呼び出すために仮想関数テーブル（VTable）を使用します。VTableは、クラスごとに作成され、各クラスの仮想関数のアドレスを格納しています。これにより、基底クラスのポインタを使って派生クラスの関数を呼び出すことができます。

純粋仮想関数と抽象クラス

純粋仮想関数は、クラス内で具体的な実装を持たない仮想関数です。純粋仮想関数を持つクラスは抽象クラスとなり、インスタンス化できなくなります。純粋仮想関数は以下のように宣言されます。

class AbstractBase {
public:
    virtual void pureVirtualFunction() = 0; // Pure virtual function
};

class ConcreteDerived : public AbstractBase {
public:
    void pureVirtualFunction() override {
        std::cout << "Implemented pure virtual function in derived class." << std::endl;
    }
};

仮想関数の基礎知識を理解することで、イベントハンドリングシステムにおける柔軟な処理の実装が可能となります。次に、イベントハンドリングシステムに必要なクラス設計の基本について説明します。

クラス設計の基本

イベントハンドリングシステムの効果的な実装には、適切なクラス設計が不可欠です。以下に、イベントハンドリングシステムに必要な基本的なクラス設計の概念を説明します。

イベントクラス

イベントクラスは、発生したイベントの情報を保持する役割を担います。このクラスには、イベントの種類や発生源、追加データなどの情報が含まれます。基本的なイベントクラスの例を示します。

class Event {
public:
    virtual ~Event() = default;
    virtual std::string getType() const = 0;
};

class MouseEvent : public Event {
public:
    std::string getType() const override {
        return "MouseEvent";
    }
    // マウスイベント固有のデータやメソッドを追加
};

class KeyboardEvent : public Event {
public:
    std::string getType() const override {
        return "KeyboardEvent";
    }
    // キーボードイベント固有のデータやメソッドを追加
};

イベントハンドラークラス

イベントハンドラークラスは、イベントを処理するための基底クラスを提供します。このクラスは、仮想関数を用いて各種イベントの処理メソッドを定義します。以下は、イベントハンドラークラスの基本的な設計例です。

class EventHandler {
public:
    virtual ~EventHandler() = default;
    virtual void handleEvent(const Event& event) = 0;
};

class MouseEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "MouseEvent") {
            // マウスイベントの処理
        }
    }
};

class KeyboardEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "KeyboardEvent") {
            // キーボードイベントの処理
        }
    }
};

イベントディスパッチャクラス

イベントディスパッチャクラスは、イベントを適切なハンドラーに振り分ける役割を持ちます。このクラスは、イベントとハンドラーの関連付けを管理し、イベント発生時に対応するハンドラーを呼び出します。以下は、イベントディスパッチャクラスの基本的な設計例です。

class EventDispatcher {
private:
    std::vector<EventHandler*> handlers;

public:
    void addHandler(EventHandler* handler) {
        handlers.push_back(handler);
    }

    void dispatch(const Event& event) {
        for (auto handler : handlers) {
            handler->handleEvent(event);
        }
    }
};

以上のクラス設計を基に、柔軟で拡張性の高いイベントハンドリングシステムを構築することが可能です。次に、これらの基本クラスの具体的な実装方法について詳しく説明します。

基本クラスの実装

ここでは、イベントハンドリングシステムの基本クラスであるイベントクラスとイベントハンドラークラスの具体的な実装例を紹介します。

イベントクラスの実装

イベントクラスは、イベントの基本的な情報を保持するためのクラスです。前述したように、これは基底クラスとして抽象的に設計され、具体的なイベントクラスがそれを継承して実装されます。

class Event {
public:
    virtual ~Event() = default;
    virtual std::string getType() const = 0;
};

class MouseEvent : public Event {
public:
    std::string getType() const override {
        return "MouseEvent";
    }

    // 追加の属性とメソッド
    int x, y;
    MouseEvent(int x, int y) : x(x), y(y) {}
};

class KeyboardEvent : public Event {
public:
    std::string getType() const override {
        return "KeyboardEvent";
    }

    // 追加の属性とメソッド
    int keyCode;
    KeyboardEvent(int keyCode) : keyCode(keyCode) {}
};

イベントハンドラークラスの実装

イベントハンドラークラスは、イベントを処理するための基本的なインターフェースを提供します。各種イベントごとに派生クラスを作成し、具体的な処理を実装します。

class EventHandler {
public:
    virtual ~EventHandler() = default;
    virtual void handleEvent(const Event& event) = 0;
};

class MouseEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "MouseEvent") {
            const MouseEvent& mouseEvent = static_cast<const MouseEvent&>(event);
            // マウスイベントの処理
            std::cout << "Mouse event at (" << mouseEvent.x << ", " << mouseEvent.y << ")" << std::endl;
        }
    }
};

class KeyboardEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "KeyboardEvent") {
            const KeyboardEvent& keyboardEvent = static_cast<const KeyboardEvent&>(event);
            // キーボードイベントの処理
            std::cout << "Key pressed: " << keyboardEvent.keyCode << std::endl;
        }
    }
};

基本クラスのまとめ

以上で、基本的なイベントクラスとイベントハンドラークラスの実装方法を解説しました。これらのクラスを基に、イベントハンドリングシステムを構築するための土台が整いました。次は、具体的な派生クラスの実装について詳しく説明します。

派生クラスの実装

基本クラスの設計と実装が完了したので、次に具体的なイベントハンドラーの派生クラスの実装方法について解説します。ここでは、マウスイベントとキーボードイベントの具体的なハンドラーを実装します。

マウスイベントハンドラーの実装

マウスイベントハンドラーは、マウスのクリックや移動などのイベントを処理します。以下は、MouseEventHandlerクラスの詳細な実装例です。

class MouseEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "MouseEvent") {
            const MouseEvent& mouseEvent = static_cast<const MouseEvent&>(event);
            // マウスイベントの処理
            handleMouseEvent(mouseEvent);
        }
    }

private:
    void handleMouseEvent(const MouseEvent& event) {
        // マウスイベントに対する具体的な処理
        std::cout << "Mouse event at (" << event.x << ", " << event.y << ")" << std::endl;
    }
};

このハンドラーは、マウスイベントが発生した際に、その座標を表示する処理を行います。

キーボードイベントハンドラーの実装

キーボードイベントハンドラーは、キーの押下やリリースなどのイベントを処理します。以下は、KeyboardEventHandlerクラスの詳細な実装例です。

class KeyboardEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "KeyboardEvent") {
            const KeyboardEvent& keyboardEvent = static_cast<const KeyboardEvent&>(event);
            // キーボードイベントの処理
            handleKeyboardEvent(keyboardEvent);
        }
    }

private:
    void handleKeyboardEvent(const KeyboardEvent& event) {
        // キーボードイベントに対する具体的な処理
        std::cout << "Key pressed: " << event.keyCode << std::endl;
    }
};

このハンドラーは、キーボードの特定のキーが押されたとき、そのキーコードを表示する処理を行います。

派生クラスの実装まとめ

派生クラスの実装により、具体的なイベントに対する処理を柔軟に行えるようになります。これにより、イベントハンドリングシステム全体の拡張性と再利用性が向上します。次に、イベントの登録と発生について説明します。

イベントの登録と発生

イベントハンドリングシステムを機能させるためには、イベントの登録方法と実際のイベント発生時の処理を理解することが重要です。ここでは、イベントの登録と発生に関する具体的な方法を説明します。

イベントの登録方法

イベントを適切に処理するためには、各イベントハンドラーをイベントディスパッチャに登録する必要があります。以下は、イベントハンドラーをディスパッチャに登録する方法の例です。

class EventDispatcher {
private:
    std::vector<EventHandler*> handlers;

public:
    void addHandler(EventHandler* handler) {
        handlers.push_back(handler);
    }

    void dispatch(const Event& event) {
        for (auto handler : handlers) {
            handler->handleEvent(event);
        }
    }
};

int main() {
    EventDispatcher dispatcher;

    MouseEventHandler mouseHandler;
    KeyboardEventHandler keyboardHandler;

    dispatcher.addHandler(&mouseHandler);
    dispatcher.addHandler(&keyboardHandler);

    // ここでイベントを生成し、ディスパッチャに渡す
    MouseEvent mouseEvent(100, 200);
    KeyboardEvent keyboardEvent(42);

    dispatcher.dispatch(mouseEvent);
    dispatcher.dispatch(keyboardEvent);

    return 0;
}

このコードでは、EventDispatcherクラスにマウスイベントハンドラーとキーボードイベントハンドラーを登録しています。dispatchメソッドを呼び出すことで、各イベントが登録されたハンドラーに渡され、適切に処理されます。

イベントの発生

イベントの発生は、ユーザー操作やシステムの状態変化によってトリガーされます。発生したイベントは、イベントディスパッチャによって適切なハンドラーに渡されます。以下は、イベントの発生とディスパッチャによる処理の流れを示す例です。

int main() {
    EventDispatcher dispatcher;

    MouseEventHandler mouseHandler;
    KeyboardEventHandler keyboardHandler;

    dispatcher.addHandler(&mouseHandler);
    dispatcher.addHandler(&keyboardHandler);

    // マウスイベントの発生
    MouseEvent mouseEvent(100, 200);
    dispatcher.dispatch(mouseEvent);

    // キーボードイベントの発生
    KeyboardEvent keyboardEvent(42);
    dispatcher.dispatch(keyboardEvent);

    return 0;
}

このコードでは、MouseEventとKeyboardEventが発生し、それぞれがEventDispatcherによって適切なハンドラーに渡されます。MouseEventはマウスの座標を、KeyboardEventはキーコードを持っています。

イベントの登録と発生まとめ

イベントの登録と発生の仕組みを理解することで、イベントハンドリングシステムを効果的に利用できます。次は、イベントを適切に処理するためのディスパッチャクラスの実装方法について詳しく説明します。

イベントディスパッチャの実装

イベントディスパッチャは、発生したイベントを適切なイベントハンドラーに振り分ける役割を持つ重要なコンポーネントです。ここでは、イベントディスパッチャの詳細な実装方法について解説します。

イベントディスパッチャクラスの設計

イベントディスパッチャクラスは、イベントハンドラーのリストを管理し、発生したイベントをそのリスト内の適切なハンドラーに渡す役割を担います。以下は、基本的なイベントディスパッチャクラスの設計です。

class EventDispatcher {
private:
    std::vector<EventHandler*> handlers;

public:
    void addHandler(EventHandler* handler) {
        handlers.push_back(handler);
    }

    void removeHandler(EventHandler* handler) {
        handlers.erase(std::remove(handlers.begin(), handlers.end(), handler), handlers.end());
    }

    void dispatch(const Event& event) {
        for (auto handler : handlers) {
            handler->handleEvent(event);
        }
    }
};

このクラスは、イベントハンドラーの追加と削除、そしてイベントのディスパッチ機能を提供します。

イベントのディスパッチ処理

イベントのディスパッチ処理は、発生したイベントを登録されたハンドラーに順次渡していくというシンプルなものです。以下のコードは、イベントディスパッチャクラスの使用例です。

int main() {
    EventDispatcher dispatcher;

    MouseEventHandler mouseHandler;
    KeyboardEventHandler keyboardHandler;

    dispatcher.addHandler(&mouseHandler);
    dispatcher.addHandler(&keyboardHandler);

    // マウスイベントの発生
    MouseEvent mouseEvent(100, 200);
    dispatcher.dispatch(mouseEvent);

    // キーボードイベントの発生
    KeyboardEvent keyboardEvent(42);
    dispatcher.dispatch(keyboardEvent);

    return 0;
}

この例では、マウスイベントとキーボードイベントが発生し、それぞれのハンドラーにディスパッチされて処理されます。

イベントディスパッチャの応用

イベントディスパッチャは、複雑なイベントハンドリングシステムにも対応できるように拡張可能です。例えば、特定の種類のイベントだけを処理するハンドラーを追加する機能や、イベントの優先順位を設定する機能を実装することができます。

以下は、特定のイベントタイプごとにハンドラーを管理するディスパッチャの例です。

class EventDispatcher {
private:
    std::unordered_map<std::string, std::vector<EventHandler*>> handlerMap;

public:
    void addHandler(const std::string& eventType, EventHandler* handler) {
        handlerMap[eventType].push_back(handler);
    }

    void dispatch(const Event& event) {
        auto it = handlerMap.find(event.getType());
        if (it != handlerMap.end()) {
            for (auto handler : it->second) {
                handler->handleEvent(event);
            }
        }
    }
};

このディスパッチャは、イベントタイプごとにハンドラーを管理し、特定のイベントが発生した際に対応するハンドラーのみを呼び出します。

イベントディスパッチャの実装まとめ

イベントディスパッチャは、イベントハンドリングシステムの中心的な役割を果たします。適切なディスパッチ処理を実装することで、柔軟で効率的なイベント処理が可能となります。次に、GUIアプリケーションへの応用例について説明します。

応用例: GUIアプリケーションへの適用

イベントハンドリングシステムは、GUIアプリケーションで非常に有用です。ここでは、C++を用いたGUIアプリケーションにおけるイベントハンドリングシステムの具体的な適用例を示します。

GUIフレームワークの選定

C++でGUIアプリケーションを開発する際に広く利用されるフレームワークには、QtやwxWidgetsなどがあります。ここでは、Qtフレームワークを使用した例を示します。

Qtを使った基本的なGUIアプリケーション

Qtは、C++で書かれたクロスプラットフォームのGUIフレームワークで、イベント駆動型プログラミングをサポートしています。以下は、Qtを使った基本的なGUIアプリケーションの例です。

#include <QApplication>
#include <QPushButton>
#include <QWidget>
#include <QVBoxLayout>

class MyWidget : public QWidget {
public:
    MyWidget(QWidget* parent = nullptr) : QWidget(parent) {
        QVBoxLayout* layout = new QVBoxLayout(this);

        QPushButton* button = new QPushButton("Click Me", this);
        layout->addWidget(button);

        connect(button, &QPushButton::clicked, this, &MyWidget::onButtonClicked);
    }

private slots:
    void onButtonClicked() {
        // ボタンがクリックされたときの処理
        qDebug("Button clicked!");
    }
};

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);

    MyWidget widget;
    widget.show();

    return app.exec();
}

このコードは、Qtフレームワークを使用してシンプルなGUIアプリケーションを作成します。QPushButtonがクリックされたときにonButtonClickedスロットが呼び出されます。

カスタムイベントの実装

Qtでは、独自のイベントを定義して処理することもできます。以下は、カスタムイベントとそのハンドラーの実装例です。

#include <QApplication>
#include <QWidget>
#include <QPushButton>
#include <QVBoxLayout>
#include <QEvent>
#include <QDebug>

class CustomEvent : public QEvent {
public:
    static const QEvent::Type EventType = static_cast<QEvent::Type>(QEvent::User + 1);

    CustomEvent() : QEvent(EventType) {}
};

class MyWidget : public QWidget {
public:
    MyWidget(QWidget* parent = nullptr) : QWidget(parent) {
        QVBoxLayout* layout = new QVBoxLayout(this);

        QPushButton* button = new QPushButton("Trigger Custom Event", this);
        layout->addWidget(button);

        connect(button, &QPushButton::clicked, this, &MyWidget::triggerCustomEvent);
    }

protected:
    void customEvent(QEvent* event) override {
        if (event->type() == CustomEvent::EventType) {
            qDebug("Custom event triggered!");
        }
    }

private slots:
    void triggerCustomEvent() {
        QApplication::postEvent(this, new CustomEvent());
    }
};

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);

    MyWidget widget;
    widget.show();

    return app.exec();
}

この例では、CustomEventクラスを定義し、ボタンがクリックされたときにカスタムイベントをトリガーします。MyWidgetクラスは、customEventメソッドをオーバーライドしてカスタムイベントを処理します。

GUIアプリケーションへの適用まとめ

このように、C++のイベントハンドリングシステムをGUIアプリケーションに適用することで、ユーザーインターフェースの操作に対して柔軟かつ効率的に対応することが可能となります。次に、ゲーム開発への応用例について説明します。

応用例: ゲーム開発への適用

ゲーム開発においても、イベントハンドリングシステムは重要な役割を果たします。ここでは、C++を用いたゲーム開発におけるイベントハンドリングシステムの具体的な適用例を示します。

ゲームエンジンの選定

C++でゲーム開発を行う際に広く利用されるゲームエンジンには、Unreal EngineやUnity（C#が主ですが、プラグインでC++も使用可能）があります。ここでは、簡単なゲームイベントシステムを構築するために、SFML（Simple and Fast Multimedia Library）を使用します。

SFMLを使った基本的なゲームイベント処理

SFMLは、シンプルで使いやすいマルチメディアライブラリで、C++でゲームを開発するのに適しています。以下は、SFMLを使った基本的なゲームイベント処理の例です。

#include <SFML/Graphics.hpp>
#include <iostream>

class Game {
public:
    Game() : window(sf::VideoMode(800, 600), "SFML Game") {}

    void run() {
        while (window.isOpen()) {
            processEvents();
            update();
            render();
        }
    }

private:
    sf::RenderWindow window;

    void processEvents() {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
            if (event.type == sf::Event::KeyPressed) {
                handlePlayerInput(event.key.code, true);
            }
            if (event.type == sf::Event::KeyReleased) {
                handlePlayerInput(event.key.code, false);
            }
        }
    }

    void update() {
        // ゲームロジックの更新
    }

    void render() {
        window.clear();
        // 描画コード
        window.display();
    }

    void handlePlayerInput(sf::Keyboard::Key key, bool isPressed) {
        if (key == sf::Keyboard::W) {
            std::cout << "Move up: " << isPressed << std::endl;
        }
        if (key == sf::Keyboard::S) {
            std::cout << "Move down: " << isPressed << std::endl;
        }
        if (key == sf::Keyboard::A) {
            std::cout << "Move left: " << isPressed << std::endl;
        }
        if (key == sf::Keyboard::D) {
            std::cout << "Move right: " << isPressed << std::endl;
        }
    }
};

int main() {
    Game game;
    game.run();
    return 0;
}

このコードでは、SFMLを使用して簡単なゲームイベント処理を行っています。キーボードの入力に応じて、対応するアクションを実行します。

カスタムイベントの実装

ゲーム開発では、カスタムイベントが必要になることが多いです。以下は、カスタムイベントを実装し、ディスパッチャを使って処理する例です。

#include <SFML/Graphics.hpp>
#include <iostream>
#include <vector>

class Event {
public:
    virtual ~Event() = default;
    virtual std::string getType() const = 0;
};

class PlayerJumpEvent : public Event {
public:
    std::string getType() const override {
        return "PlayerJumpEvent";
    }
};

class EventHandler {
public:
    virtual ~EventHandler() = default;
    virtual void handleEvent(const Event& event) = 0;
};

class PlayerEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "PlayerJumpEvent") {
            std::cout << "Player jumped!" << std::endl;
        }
    }
};

class EventDispatcher {
private:
    std::vector<EventHandler*> handlers;

public:
    void addHandler(EventHandler* handler) {
        handlers.push_back(handler);
    }

    void dispatch(const Event& event) {
        for (auto handler : handlers) {
            handler->handleEvent(event);
        }
    }
};

int main() {
    EventDispatcher dispatcher;
    PlayerEventHandler playerHandler;

    dispatcher.addHandler(&playerHandler);

    PlayerJumpEvent jumpEvent;
    dispatcher.dispatch(jumpEvent);

    return 0;
}

この例では、PlayerJumpEventというカスタムイベントを定義し、それを処理するPlayerEventHandlerを作成しています。イベントディスパッチャを使用して、イベントを適切なハンドラーに渡しています。

ゲーム開発への適用まとめ

ゲーム開発におけるイベントハンドリングシステムは、プレイヤーの入力やゲーム内イベントの処理に重要な役割を果たします。ここで紹介した基本的な例を基に、さらに複雑なイベントシステムを構築することができます。次に、学習内容を確認するための演習問題を提供します。

演習問題

以下に、C++の仮想関数を使ったイベントハンドリングシステムの理解を深めるための演習問題を提供します。各問題に取り組むことで、実装方法や応用についての理解が深まるでしょう。

演習1: 基本的なイベントハンドラーの実装

  1. 以下の要件を満たすイベントハンドリングシステムを実装してください。
    • 基底クラスとしてEventクラスとEventHandlerクラスを定義する。
    • MouseEventクラスとKeyboardEventクラスをEventクラスから派生させる。
    • MouseEventHandlerクラスとKeyboardEventHandlerクラスをEventHandlerクラスから派生させ、それぞれのイベントを処理するメソッドを実装する。

サンプルコードのヒント

class Event {
public:
    virtual ~Event() = default;
    virtual std::string getType() const = 0;
};

class MouseEvent : public Event {
public:
    std::string getType() const override {
        return "MouseEvent";
    }
    int x, y;
    MouseEvent(int x, int y) : x(x), y(y) {}
};

class KeyboardEvent : public Event {
public:
    std::string getType() const override {
        return "KeyboardEvent";
    }
    int keyCode;
    KeyboardEvent(int keyCode) : keyCode(keyCode) {}
};

class EventHandler {
public:
    virtual ~EventHandler() = default;
    virtual void handleEvent(const Event& event) = 0;
};

class MouseEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "MouseEvent") {
            const MouseEvent& mouseEvent = static_cast<const MouseEvent&>(event);
            // マウスイベントの処理
            std::cout << "Mouse event at (" << mouseEvent.x << ", " << mouseEvent.y << ")" << std::endl;
        }
    }
};

class KeyboardEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "KeyboardEvent") {
            const KeyboardEvent& keyboardEvent = static_cast<const KeyboardEvent&>(event);
            // キーボードイベントの処理
            std::cout << "Key pressed: " << keyboardEvent.keyCode << std::endl;
        }
    }
};

演習2: イベントディスパッチャの拡張

  1. 前の演習で実装したシステムに、以下の機能を追加してください。
    • イベントディスパッチャクラスを作成し、複数のハンドラーを登録できるようにする。
    • イベントが発生したときに、適切なハンドラーにイベントを渡して処理させる。

サンプルコードのヒント

class EventDispatcher {
private:
    std::vector<EventHandler*> handlers;

public:
    void addHandler(EventHandler* handler) {
        handlers.push_back(handler);
    }

    void dispatch(const Event& event) {
        for (auto handler : handlers) {
            handler->handleEvent(event);
        }
    }
};

int main() {
    EventDispatcher dispatcher;

    MouseEventHandler mouseHandler;
    KeyboardEventHandler keyboardHandler;

    dispatcher.addHandler(&mouseHandler);
    dispatcher.addHandler(&keyboardHandler);

    // マウスイベントの発生
    MouseEvent mouseEvent(100, 200);
    dispatcher.dispatch(mouseEvent);

    // キーボードイベントの発生
    KeyboardEvent keyboardEvent(42);
    dispatcher.dispatch(keyboardEvent);

    return 0;
}

演習3: カスタムイベントの実装

  1. 独自のカスタムイベントクラスを作成し、そのイベントを処理するハンドラーを実装してください。
    • CustomEventクラスをEventクラスから派生させる。
    • CustomEventHandlerクラスをEventHandlerクラスから派生させ、カスタムイベントを処理するメソッドを実装する。

サンプルコードのヒント

class CustomEvent : public Event {
public:
    std::string getType() const override {
        return "CustomEvent";
    }
    // カスタムイベント固有のデータやメソッドを追加
};

class CustomEventHandler : public EventHandler {
public:
    void handleEvent(const Event& event) override {
        if (event.getType() == "CustomEvent") {
            // カスタムイベントの処理
            std::cout << "Custom event triggered!" << std::endl;
        }
    }
};

int main() {
    EventDispatcher dispatcher;

    CustomEventHandler customHandler;
    dispatcher.addHandler(&customHandler);

    // カスタムイベントの発生
    CustomEvent customEvent;
    dispatcher.dispatch(customEvent);

    return 0;
}

演習問題のまとめ

これらの演習問題を通じて、C++の仮想関数を用いたイベントハンドリングシステムの設計と実装について実践的に学ぶことができます。各演習に取り組むことで、実際の開発における応用力が身につくでしょう。次に、本記事のまとめを行います。

まとめ

本記事では、C++の仮想関数を用いたイベントハンドリングシステムの実装方法について詳しく解説しました。まず、イベントハンドリングシステムの基本概念を理解し、仮想関数の基礎知識を学びました。次に、基本クラスと派生クラスの実装方法を通じて、実際のコードによる具体例を示しました。さらに、イベントの登録と発生、イベントディスパッチャの設計と実装、そしてGUIアプリケーションやゲーム開発への応用例を紹介しました。

最後に、学習内容を確認するための演習問題を提供しました。これらの演習に取り組むことで、イベントハンドリングシステムの実装技術を実践的に習得できるでしょう。C++の仮想関数を活用した柔軟で拡張性のあるシステム設計は、さまざまなアプリケーションで重要な役割を果たします。今後のプロジェクトにおいて、これらの知識と技術を活用して、効率的なコード設計を目指してください。

C++
イベントハンドリング C++ 仮想関数

コメント

コメントする

目次