MENU
  1. ホーム
  2. C++
  3. C++におけるポリモーフィズムと条件分岐の違いと使い分け

C++におけるポリモーフィズムと条件分岐の違いと使い分け

C++

C++プログラミングにおいて、ポリモーフィズムと条件分岐は非常に重要な概念です。これらはプログラムの設計と可読性に大きな影響を与えます。本記事では、ポリモーフィズムと条件分岐の基本概念、それぞれの具体的な使用例、設計パターン、そして実際の応用例を通じて、これらの概念をどのように効果的に使い分けるかを詳しく解説します。

目次

ポリモーフィズムの基本概念

ポリモーフィズム（多態性）は、オブジェクト指向プログラミングの中心的な概念の一つです。C++においては、同じインターフェースを共有しつつ異なる具体的な実装を持つオブジェクトを扱うことを可能にします。これにより、コードの柔軟性と再利用性が向上し、メンテナンスが容易になります。

ポリモーフィズムの定義

ポリモーフィズムは、異なるクラスのオブジェクトが同じメソッドを共有し、実行時にそのメソッドの実装が動的に決定される特性です。これにより、同じコードベースで異なるオブジェクトを扱うことができます。

ポリモーフィズムの重要性

ポリモーフィズムは、ソフトウェアの設計をシンプルかつ柔軟に保つために重要です。具体的には、以下のような利点があります。

  • コードの再利用性: 一度定義したインターフェースを複数のクラスで共有できるため、同じコードを再利用しやすくなります。
  • 拡張性: 新しいクラスを追加する際に既存のコードを変更せずに済むため、システムの拡張が容易になります。
  • メンテナンス性: 変更が必要な場合に、特定の実装だけを変更すれば良いので、コードのメンテナンスが容易になります。

条件分岐の基本概念

条件分岐は、プログラムの流れを制御するための基本的な構造です。C++では、if文やswitch文を使用して、特定の条件に基づいて異なるコードブロックを実行することができます。条件分岐を適切に使うことで、プログラムが動的な入力や状況に応じて異なる動作をするように設計できます。

条件分岐の仕組み

条件分岐は、プログラムが特定の条件を満たすかどうかを評価し、それに基づいて異なる処理を実行します。主な条件分岐の構文には以下のものがあります。

if文

if文は、指定した条件が真（true）である場合にのみブロック内のコードを実行します。

int x = 10;
if (x > 5) {
    std::cout << "xは5より大きい" << std::endl;
}

else文

else文は、if文の条件が偽（false）である場合に実行されるブロックを指定します。

int x = 3;
if (x > 5) {
    std::cout << "xは5より大きい" << std::endl;
} else {
    std::cout << "xは5以下" << std::endl;
}

else if文

else if文は、複数の条件を順次評価し、最初に真となった条件のブロックを実行します。

int x = 5;
if (x > 5) {
    std::cout << "xは5より大きい" << std::endl;
} else if (x == 5) {
    std::cout << "xは5と等しい" << std::endl;
} else {
    std::cout << "xは5より小さい" << std::endl;
}

switch文

switch文は、変数の値に基づいて複数のケースの中から一つを選択して実行します。

int day = 3;
switch (day) {
    case 1:
        std::cout << "月曜日" << std::endl;
        break;
    case 2:
        std::cout << "火曜日" << std::endl;
        break;
    case 3:
        std::cout << "水曜日" << std::endl;
        break;
    default:
        std::cout << "その他の曜日" << std::endl;
        break;
}

条件分岐の使用例

条件分岐は、ユーザー入力の処理、ゲームロジックの構築、状態遷移の管理など、さまざまな場面で使用されます。適切な条件分岐を設けることで、プログラムの動作を柔軟に制御できます。

ポリモーフィズムと条件分岐の比較

ポリモーフィズムと条件分岐は、いずれもプログラムの動作を制御するための手法ですが、それぞれ異なる利点と適用範囲があります。ここでは、両者の違いと使い分けについて比較します。

ポリモーフィズムの特徴

ポリモーフィズムは、オブジェクト指向プログラミングの概念であり、主に以下の特徴があります。

  • 柔軟性: オブジェクトの種類が増えても、コードの変更が最小限で済みます。
  • 拡張性: 新しいクラスを追加しても既存のコードに影響を与えないため、システムの拡張が容易です。
  • 再利用性: インターフェースや抽象クラスを使用することで、共通のコードを再利用できます。

ポリモーフィズムの適用例

ポリモーフィズムは、例えばゲーム開発におけるキャラクターの動作、GUIアプリケーションにおけるウィジェットの操作など、異なる実装を持つオブジェクトを同じ方法で扱いたい場合に有効です。

条件分岐の特徴

条件分岐は、プログラムの特定の条件に基づいて異なる処理を行うための構造で、以下の特徴があります。

  • シンプルさ: 比較的単純な処理や少数の条件を扱う場合に適しています。
  • 明確性: 条件とその処理が明確に分かれているため、コードの流れがわかりやすいです。

条件分岐の適用例

条件分岐は、ユーザーの入力に応じた処理、メニュー選択、エラーハンドリングなど、明確な条件に基づく分岐が必要な場合に有効です。

ポリモーフィズムと条件分岐の使い分け

  • ポリモーフィズムの使用例: 多様なオブジェクトを同一のインターフェースで扱う必要がある場合（例：動物クラスの多態性）。
  • 条件分岐の使用例: 明確な条件に基づく処理が必要な場合（例：ユーザーの入力によるメニュー選択）。

両者を適切に使い分けることで、プログラムの設計がより効率的で柔軟になります。

ポリモーフィズムの具体的な例

ポリモーフィズムを理解するために、具体的なコード例を用いてその使い方を説明します。ここでは、動物の鳴き声をシミュレートする簡単なプログラムを例に取り上げます。

ポリモーフィズムの基本コード例

以下のコードでは、Animalという抽象クラスを定義し、これを継承するDogとCatのクラスを作成します。それぞれのクラスで鳴き声を実装し、ポリモーフィズムを利用して一貫したインターフェースで処理します。

#include <iostream>
#include <vector>

// 抽象クラス Animal
class Animal {
public:
    virtual void makeSound() const = 0; // 純粋仮想関数
    virtual ~Animal() {}
};

// 派生クラス Dog
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof!" << std::endl;
    }
};

// 派生クラス Cat
class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    std::vector<Animal*> animals;
    animals.push_back(new Dog());
    animals.push_back(new Cat());

    for (const auto& animal : animals) {
        animal->makeSound(); // ポリモーフィズムによるメソッド呼び出し
    }

    // メモリの解放
    for (auto& animal : animals) {
        delete animal;
    }

    return 0;
}

コードの説明

  1. Animalクラス: 抽象クラスであり、純粋仮想関数makeSoundを持ちます。この関数は派生クラスで実装される必要があります。
  2. Dogクラス: Animalクラスを継承し、makeSound関数をオーバーライドして犬の鳴き声を実装します。
  3. Catクラス: Animalクラスを継承し、makeSound関数をオーバーライドして猫の鳴き声を実装します。
  4. main関数: Animalクラスのポインタのベクターを作成し、DogとCatのインスタンスを追加します。ベクターをループして各動物のmakeSoundメソッドを呼び出します。これにより、ポリモーフィズムが発揮され、それぞれのオブジェクトの正しいメソッドが呼び出されます。

ポリモーフィズムの利点

  • 柔軟性: 異なる動物クラスを同一のインターフェースで扱えるため、コードの変更が容易です。
  • 拡張性: 新しい動物クラスを追加する場合も、既存のコードを変更する必要がありません。

条件分岐の具体的な例

条件分岐を理解するために、具体的なコード例を用いてその使い方を説明します。ここでは、ユーザーの入力に基づいてメニューを選択する簡単なプログラムを例に取り上げます。

条件分岐の基本コード例

以下のコードでは、ユーザーに対してメニューを表示し、選択されたオプションに基づいて異なるメッセージを表示します。

#include <iostream>

int main() {
    int choice;

    std::cout << "メニューを選択してください:\n";
    std::cout << "1. オプション1\n";
    std::cout << "2. オプション2\n";
    std::cout << "3. オプション3\n";
    std::cout << "選択: ";
    std::cin >> choice;

    if (choice == 1) {
        std::cout << "オプション1が選択されました。\n";
    } else if (choice == 2) {
        std::cout << "オプション2が選択されました。\n";
    } else if (choice == 3) {
        std::cout << "オプション3が選択されました。\n";
    } else {
        std::cout << "無効な選択です。\n";
    }

    return 0;
}

コードの説明

  1. メニューの表示: ユーザーに対して選択可能なオプションを表示します。
  2. ユーザー入力の取得: 標準入力から選択されたオプションを取得します。
  3. 条件分岐の使用: if、else if、およびelse文を使用して、ユーザーの選択に基づいて異なるメッセージを表示します。

if文

選択されたオプションが1の場合、対応するメッセージを表示します。

if (choice == 1) {
    std::cout << "オプション1が選択されました。\n";
}

else if文

選択されたオプションが2の場合、対応するメッセージを表示します。

else if (choice == 2) {
    std::cout << "オプション2が選択されました。\n";
}

else文

選択されたオプションが3の場合、対応するメッセージを表示します。それ以外の場合は無効な選択とします。

else if (choice == 3) {
    std::cout << "オプション3が選択されました。\n";
} else {
    std::cout << "無効な選択です。\n";
}

条件分岐の利点

  • シンプルさ: 簡単な条件に基づく処理を直感的に記述できます。
  • 明確性: 条件とその処理がコード内で明確に分かれており、理解しやすいです。

条件分岐は、ユーザーインターフェースの設計やエラーハンドリングなど、明確な条件に基づく処理が必要な場面で特に有効です。

ポリモーフィズムを用いた設計パターン

ポリモーフィズムは、オブジェクト指向プログラミングの設計パターンにおいて重要な役割を果たします。ここでは、ポリモーフィズムを活用した代表的な設計パターンをいくつか紹介します。

Strategyパターン

Strategyパターンは、アルゴリズムをクラスとして定義し、コンテキスト（使用側）で動的にアルゴリズムを変更できるようにするパターンです。

Strategyパターンの例

以下のコードでは、異なる割引戦略を使用するショッピングカートを例に説明します。

#include <iostream>
#include <memory>

// 割引戦略の抽象クラス
class DiscountStrategy {
public:
    virtual double applyDiscount(double price) const = 0;
    virtual ~DiscountStrategy() {}
};

// 固定額割引クラス
class FixedDiscount : public DiscountStrategy {
public:
    double applyDiscount(double price) const override {
        return price - 10.0;
    }
};

// 割引なしクラス
class NoDiscount : public DiscountStrategy {
public:
    double applyDiscount(double price) const override {
        return price;
    }
};

// ショッピングカートクラス
class ShoppingCart {
private:
    std::unique_ptr<DiscountStrategy> discountStrategy;
public:
    ShoppingCart(std::unique_ptr<DiscountStrategy> strategy)
        : discountStrategy(std::move(strategy)) {}
    double calculateTotal(double price) const {
        return discountStrategy->applyDiscount(price);
    }
};

int main() {
    ShoppingCart cart1(std::make_unique<FixedDiscount>());
    ShoppingCart cart2(std::make_unique<NoDiscount>());

    std::cout << "Cart1 Total: " << cart1.calculateTotal(100.0) << std::endl;
    std::cout << "Cart2 Total: " << cart2.calculateTotal(100.0) << std::endl;

    return 0;
}

コードの説明

  • DiscountStrategyクラス: 割引戦略のインターフェースを定義します。
  • FixedDiscountクラスとNoDiscountクラス: それぞれ異なる割引戦略を実装します。
  • ShoppingCartクラス: コンテキストクラスとして、割引戦略を動的に変更できるようにします。

Factoryパターン

Factoryパターンは、オブジェクトの生成を専門とするクラスを設けることで、オブジェクト生成の詳細を隠蔽するパターンです。

Factoryパターンの例

以下のコードでは、動物オブジェクトを生成するファクトリを例に説明します。

#include <iostream>
#include <memory>

class Animal {
public:
    virtual void makeSound() const = 0;
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow!" << std::endl;
    }
};

class AnimalFactory {
public:
    static std::unique_ptr<Animal> createAnimal(const std::string& type) {
        if (type == "dog") {
            return std::make_unique<Dog>();
        } else if (type == "cat") {
            return std::make_unique<Cat>();
        } else {
            return nullptr;
        }
    }
};

int main() {
    auto dog = AnimalFactory::createAnimal("dog");
    auto cat = AnimalFactory::createAnimal("cat");

    if (dog) dog->makeSound();
    if (cat) cat->makeSound();

    return 0;
}

コードの説明

  • Animalクラス、Dogクラス、Catクラス: それぞれ動物の抽象クラスと具体的な実装クラスです。
  • AnimalFactoryクラス: 動物オブジェクトを生成するファクトリクラスです。

ポリモーフィズムの利点

  • コードの柔軟性: 同じインターフェースを共有することで、異なる実装を簡単に切り替えられます。
  • 拡張性: 新しいクラスを追加しても、既存のコードを変更せずに機能を拡張できます。

ポリモーフィズムを用いた設計パターンを理解し活用することで、柔軟で拡張性の高いシステムを構築することができます。

条件分岐を用いた設計パターン

条件分岐は、特定の条件に基づいて異なる処理を行うための基本的な手法です。ここでは、条件分岐を活用した代表的な設計パターンをいくつか紹介します。

Stateパターン

Stateパターンは、オブジェクトが内部状態に応じてその動作を変更するパターンです。各状態をクラスとして定義し、状態ごとの処理を分けることで、条件分岐を管理します。

Stateパターンの例

以下のコードでは、電球のオン・オフ状態を管理する例を用いて説明します。

#include <iostream>
#include <memory>

class State {
public:
    virtual void handle() = 0;
    virtual ~State() {}
};

class OnState : public State {
public:
    void handle() override {
        std::cout << "電球が点灯しています。" << std::endl;
    }
};

class OffState : public State {
public:
    void handle() override {
        std::cout << "電球が消灯しています。" << std::endl;
    }
};

class LightContext {
private:
    std::unique_ptr<State> state;
public:
    LightContext(std::unique_ptr<State> initialState)
        : state(std::move(initialState)) {}

    void setState(std::unique_ptr<State> newState) {
        state = std::move(newState);
    }

    void request() {
        state->handle();
    }
};

int main() {
    LightContext light(std::make_unique<OffState>());
    light.request();

    light.setState(std::make_unique<OnState>());
    light.request();

    return 0;
}

コードの説明

  • Stateクラス: 状態を表す抽象クラスで、具体的な状態に応じたhandleメソッドを定義します。
  • OnStateクラスとOffStateクラス: 状態に応じた処理を実装します。
  • LightContextクラス: 状態を持つコンテキストクラスで、状態の変更と処理の要求を管理します。

Chain of Responsibilityパターン

Chain of Responsibilityパターンは、リクエストを処理する一連の処理オブジェクトを形成し、リクエストを次々と処理オブジェクトに渡していくパターンです。条件に応じて次のオブジェクトに処理を委譲します。

Chain of Responsibilityパターンの例

以下のコードでは、異なるレベルのエラーハンドリングを行う例を用いて説明します。

#include <iostream>
#include <memory>

class Handler {
protected:
    std::unique_ptr<Handler> next;
public:
    void setNext(std::unique_ptr<Handler> nextHandler) {
        next = std::move(nextHandler);
    }
    virtual void handleRequest(int level) = 0;
    virtual ~Handler() {}
};

class InfoHandler : public Handler {
public:
    void handleRequest(int level) override {
        if (level == 1) {
            std::cout << "情報レベルのエラー処理" << std::endl;
        } else if (next) {
            next->handleRequest(level);
        }
    }
};

class WarningHandler : public Handler {
public:
    void handleRequest(int level) override {
        if (level == 2) {
            std::cout << "警告レベルのエラー処理" << std::endl;
        } else if (next) {
            next->handleRequest(level);
        }
    }
};

class ErrorHandler : public Handler {
public:
    void handleRequest(int level) override {
        if (level == 3) {
            std::cout << "エラーレベルのエラー処理" << std::endl;
        } else if (next) {
            next->handleRequest(level);
        }
    }
};

int main() {
    std::unique_ptr<Handler> errorHandler = std::make_unique<ErrorHandler>();
    std::unique_ptr<Handler> warningHandler = std::make_unique<WarningHandler>();
    std::unique_ptr<Handler> infoHandler = std::make_unique<InfoHandler>();

    infoHandler->setNext(std::move(warningHandler));
    infoHandler->next->setNext(std::move(errorHandler));

    infoHandler->handleRequest(2);
    infoHandler->handleRequest(3);
    infoHandler->handleRequest(1);

    return 0;
}

コードの説明

  • Handlerクラス: リクエストを処理する抽象クラスで、次のハンドラをチェーンとして保持します。
  • InfoHandlerクラス、WarningHandlerクラス、ErrorHandlerクラス: 各レベルのエラーハンドリングを実装します。

条件分岐の利点

  • 明確な処理フロー: 条件ごとに明確に処理が分かれるため、コードの流れが理解しやすいです。
  • シンプルなロジック: 単純な条件に基づく処理を直感的に記述できます。

条件分岐を用いた設計パターンは、特定の条件に基づく処理が多いシステムで有効です。これらのパターンを理解し、適切に活用することで、より効果的なプログラムを設計することができます。

応用例：ゲーム開発におけるポリモーフィズムと条件分岐

ゲーム開発では、ポリモーフィズムと条件分岐の両方が頻繁に使用されます。それぞれの特性を理解し、適切に使い分けることで、効率的で柔軟なゲームシステムを構築できます。ここでは、ゲーム開発における具体例を通じて、ポリモーフィズムと条件分岐の使い分けを説明します。

ポリモーフィズムの応用例

ポリモーフィズムを活用することで、異なるキャラクターやアイテムを一貫した方法で扱うことができます。例えば、ゲーム内のキャラクターがそれぞれ異なる攻撃方法を持っている場合、ポリモーフィズムを使用してこれを管理します。

ポリモーフィズムを使用したキャラクター攻撃

#include <iostream>
#include <vector>
#include <memory>

// 抽象クラス Character
class Character {
public:
    virtual void attack() const = 0;
    virtual ~Character() {}
};

// 派生クラス Warrior
class Warrior : public Character {
public:
    void attack() const override {
        std::cout << "Warrior attacks with sword!" << std::endl;
    }
};

// 派生クラス Mage
class Mage : public Character {
public:
    void attack() const override {
        std::cout << "Mage attacks with fireball!" << std::endl;
    }
};

int main() {
    std::vector<std::unique_ptr<Character>> characters;
    characters.push_back(std::make_unique<Warrior>());
    characters.push_back(std::make_unique<Mage>());

    for (const auto& character : characters) {
        character->attack(); // ポリモーフィズムによる攻撃
    }

    return 0;
}

コードの説明

  • Characterクラス: 攻撃メソッドを持つ抽象クラスです。
  • WarriorクラスとMageクラス: それぞれ異なる攻撃方法を実装する派生クラスです。
  • main関数: キャラクターのリストを作成し、ポリモーフィズムを利用して一貫した方法で攻撃を実行します。

条件分岐の応用例

条件分岐を使用して、ゲーム内のイベントや状態遷移を管理することができます。例えば、プレイヤーの入力に応じたメニュー選択や、特定のゲーム状態に基づく処理などが挙げられます。

条件分岐を使用したゲームメニュー

#include <iostream>

enum GameState { MENU, PLAY, GAME_OVER };

int main() {
    GameState state = MENU;

    while (true) {
        if (state == MENU) {
            std::cout << "1. Play Game\n";
            std::cout << "2. Exit\n";
            int choice;
            std::cin >> choice;

            if (choice == 1) {
                state = PLAY;
            } else if (choice == 2) {
                break;
            }
        } else if (state == PLAY) {
            std::cout << "Playing the game...\n";
            std::cout << "Press 0 to go back to menu\n";
            int choice;
            std::cin >> choice;

            if (choice == 0) {
                state = MENU;
            }
        } else if (state == GAME_OVER) {
            std::cout << "Game Over. Press 0 to go back to menu\n";
            int choice;
            std::cin >> choice;

            if (choice == 0) {
                state = MENU;
            }
        }
    }

    return 0;
}

コードの説明

  • GameState列挙型: ゲームの状態を表す列挙型です。
  • main関数: ゲームの状態に基づいて異なる処理を行います。条件分岐を使用して、ユーザーの入力に応じた状態遷移を実現します。

ポリモーフィズムと条件分岐の使い分け

  • ポリモーフィズムの使用例: キャラクターの多様な動作やアイテムの振る舞いなど、共通のインターフェースを持つオブジェクトの管理に適しています。
  • 条件分岐の使用例: ゲームの状態管理やユーザー入力による動的な処理など、明確な条件に基づく分岐に適しています。

ゲーム開発においては、ポリモーフィズムと条件分岐を適切に使い分けることで、柔軟で拡張性の高いシステムを構築できます。

演習問題

ポリモーフィズムと条件分岐の理解を深めるために、以下の演習問題に取り組んでみましょう。これらの問題は、C++の基本的な知識と、ポリモーフィズムや条件分岐の応用力を試すものです。

演習問題1: ポリモーフィズムを使った図形クラス

以下の要件を満たす図形クラス群を作成してください。

  1. 抽象クラスShapeを定義し、純粋仮想関数area()を持たせる。
  2. Shapeクラスを継承したCircleクラスとRectangleクラスを作成し、それぞれarea()関数を実装する。
  3. main関数で、CircleとRectangleのインスタンスを作成し、それらの面積を表示する。
#include <iostream>
#include <memory>
#include <vector>
#include <cmath>

class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {
        return M_PI * radius * radius;
    }
};

class Rectangle : public Shape {
private:
    double width;
    double height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override {
        return width * height;
    }
};

int main() {
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(5.0));
    shapes.push_back(std::make_unique<Rectangle>(4.0, 6.0));

    for (const auto& shape : shapes) {
        std::cout << "Area: " << shape->area() << std::endl;
    }

    return 0;
}

演習問題2: 条件分岐を使った簡易電卓

ユーザーの入力に基づいて、加算、減算、乗算、除算を行う簡易電卓を作成してください。以下の手順に従って実装を行います。

  1. ユーザーから2つの数値と演算子（+、-、*、/）を入力させる。
  2. 入力された演算子に基づいて、条件分岐を使用して対応する計算を実行する。
  3. 結果を表示する。
#include <iostream>

int main() {
    double num1, num2;
    char op;

    std::cout << "Enter first number: ";
    std::cin >> num1;
    std::cout << "Enter operator (+, -, *, /): ";
    std::cin >> op;
    std::cout << "Enter second number: ";
    std::cin >> num2;

    if (op == '+') {
        std::cout << "Result: " << num1 + num2 << std::endl;
    } else if (op == '-') {
        std::cout << "Result: " << num1 - num2 << std::endl;
    } else if (op == '*') {
        std::cout << "Result: " << num1 * num2 << std::endl;
    } else if (op == '/') {
        if (num2 != 0) {
            std::cout << "Result: " << num1 / num2 << std::endl;
        } else {
            std::cout << "Error: Division by zero" << std::endl;
        }
    } else {
        std::cout << "Invalid operator" << std::endl;
    }

    return 0;
}

これらの演習問題を通じて、ポリモーフィズムと条件分岐の実際の使用方法を実践的に学びましょう。解答例を参考にしつつ、自分でコードを書いて試してみてください。

まとめ

本記事では、C++におけるポリモーフィズムと条件分岐の基本概念、具体的な使用例、およびそれぞれの設計パターンについて詳しく解説しました。ポリモーフィズムは、オブジェクト指向プログラミングの強力な特性であり、コードの柔軟性と拡張性を高めます。一方、条件分岐は、明確な条件に基づく処理を行う際に欠かせない基本構造です。

これらの概念を理解し、適切に使い分けることで、効率的で保守性の高いプログラムを設計できます。演習問題に取り組むことで、実践的なスキルをさらに深めてください。ポリモーフィズムと条件分岐の両方をマスターすることで、C++プログラミングの幅が広がり、より複雑なシステムの設計が可能になります。

C++
プログラミング コード例 条件分岐 ポリモーフィズム 設計パターン ゲーム開発 C++

コメント

コメントする

目次