MENU
  1. ホーム
  2. C++
  3. C++で仮想関数を使ったファクトリーパターンの実装と応用例

C++で仮想関数を使ったファクトリーパターンの実装と応用例

C++

仮想関数とデザインパターンは、C++プログラミングにおいて重要な概念です。特にデザインパターンは、再利用可能でメンテナンスしやすいコードを書くための設計指針を提供します。本記事では、仮想関数を使ったデザインパターン、特にファクトリーパターンの実装方法と応用例について解説します。ファクトリーパターンを理解し、実際にC++で実装することで、プログラムの柔軟性と拡張性を高めることができます。まずは、仮想関数とデザインパターンの基礎から始めましょう。

目次

仮想関数の基礎

仮想関数（virtual function）は、C++のポリモーフィズムを実現するための重要な要素です。仮想関数を使うことで、基底クラスのポインタや参照を通じて派生クラスのメンバ関数を呼び出すことができます。これにより、異なるクラス間で同じインターフェースを提供し、動的なメソッドの切り替えを可能にします。

仮想関数の宣言

仮想関数は、基底クラスで宣言され、派生クラスでオーバーライドされることを前提としています。以下は、仮想関数の基本的な宣言方法です。

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

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

仮想関数の利用例

仮想関数の利用例として、基底クラスのポインタを使って派生クラスのメソッドを呼び出す方法を示します。

void showDisplay(Base* b) {
    b->display();
}

int main() {
    Base b;
    Derived d;
    showDisplay(&b);  // 出力: Base display
    showDisplay(&d);  // 出力: Derived display
    return 0;
}

このように、仮想関数を使うことで、基底クラスのポインタを通じて派生クラスのメソッドを動的に呼び出すことができます。これが、ポリモーフィズムの基本的な形態です。次に、デザインパターンの概要について説明します。

デザインパターンとは

デザインパターンは、ソフトウェア設計において繰り返し使用される解決策のテンプレートです。これにより、開発者は特定の設計問題に対して再利用可能で最適な解決策を見つけることができます。デザインパターンは、オブジェクト指向設計の中で特に重要な役割を果たし、コードの再利用性、可読性、保守性を向上させます。

デザインパターンの分類

デザインパターンは、一般に以下の三つのカテゴリに分類されます：

  1. 生成に関するパターン（Creational Patterns）: オブジェクトの生成方法に関するパターンです。例としては、シングルトン、ファクトリー、アブストラクトファクトリーなどがあります。
  2. 構造に関するパターン（Structural Patterns）: クラスやオブジェクトを組み合わせて新しい機能を作り出すパターンです。例としては、アダプター、ブリッジ、デコレーターなどがあります。
  3. 振る舞いに関するパターン（Behavioral Patterns）: オブジェクト間のコミュニケーションに関するパターンです。例としては、オブザーバー、ストラテジー、コマンドなどがあります。

デザインパターンの利点

デザインパターンを使用することには多くの利点があります：

  • 再利用性の向上: デザインパターンは汎用的で再利用可能なコードを提供します。
  • 保守性の向上: パターンに基づいた設計は、変更が容易で保守がしやすいです。
  • 可読性の向上: 一貫した設計パターンを使用することで、コードの理解が容易になります。
  • 開発効率の向上: 過去の成功した解決策を再利用することで、開発時間を短縮できます。

デザインパターンの理解と適用は、ソフトウェア開発者にとって非常に有益です。次に、具体的なファクトリーパターンの概要について説明します。

ファクトリーパターンの概要

ファクトリーパターンは、オブジェクトの生成を専門化するためのデザインパターンです。これにより、クライアントコードは、具体的なクラスを直接インスタンス化することなく、オブジェクトを生成することができます。このパターンは、生成に関するパターン（Creational Patterns）の一つです。

ファクトリーパターンの基本構造

ファクトリーパターンは、主に以下の要素から構成されます：

  1. ファクトリーメソッド（Factory Method）: オブジェクト生成をカプセル化するメソッドです。
  2. プロダクト（Product）: ファクトリーメソッドが生成するオブジェクトのインターフェースまたは抽象クラスです。
  3. コンクリートプロダクト（Concrete Product）: プロダクトインターフェースを実装する具体的なクラスです。

以下は、ファクトリーパターンの基本構造を示すクラス図です：

+--------------------+                +-------------------------+
|     Creator        |                |         Product         |
|--------------------|                |-------------------------|
| + factoryMethod()  |<>------------->| + operation()           |
+--------------------+                +-------------------------+
        |                                      ^
        |                                      |
        v                                      |
+--------------------+                +-------------------------+
| ConcreteCreator    |                |  ConcreteProduct        |
|--------------------|                |-------------------------|
| + factoryMethod()  |                | + operation()           |
+--------------------+                +-------------------------+

ファクトリーパターンの利点

ファクトリーパターンを使用することには以下の利点があります：

  • 生成のカプセル化: オブジェクト生成の詳細を隠蔽し、クライアントコードを簡潔に保ちます。
  • 柔軟性の向上: 新しい種類のプロダクトを追加する際に、既存のクライアントコードを変更する必要がありません。
  • 一貫性の確保: オブジェクト生成の一貫性を保ち、コードの整合性を高めます。

次に、C++での具体的なファクトリーパターンの実装例について説明します。

ファクトリーパターンの実装例

ここでは、C++でのファクトリーパターンの具体的な実装例を紹介します。この例では、異なるタイプの製品を生成するためのファクトリーパターンを実装します。

基本的なクラス設計

まず、製品のインターフェースとなる抽象クラス Product を定義し、その具体的な実装クラス ConcreteProductA と ConcreteProductB を作成します。また、ファクトリーメソッドを持つ Factory クラスも定義します。

#include <iostream>
#include <memory>

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

// 具体クラス ConcreteProductA
class ConcreteProductA : public Product {
public:
    void use() const override {
        std::cout << "Using Product A" << std::endl;
    }
};

// 具体クラス ConcreteProductB
class ConcreteProductB : public Product {
public:
    void use() const override {
        std::cout << "Using Product B" << std::endl;
    }
};

// ファクトリークラス Factory
class Factory {
public:
    enum class ProductType {
        ProductA,
        ProductB
    };

    static std::unique_ptr<Product> createProduct(ProductType type) {
        switch (type) {
        case ProductType::ProductA:
            return std::make_unique<ConcreteProductA>();
        case ProductType::ProductB:
            return std::make_unique<ConcreteProductB>();
        default:
            throw std::invalid_argument("Unknown product type");
        }
    }
};

ファクトリーパターンの利用例

次に、ファクトリーパターンを使用して製品を生成し、利用する例を示します。

int main() {
    // ProductAを生成
    auto productA = Factory::createProduct(Factory::ProductType::ProductA);
    productA->use();  // 出力: Using Product A

    // ProductBを生成
    auto productB = Factory::createProduct(Factory::ProductType::ProductB);
    productB->use();  // 出力: Using Product B

    return 0;
}

この例では、Factory クラスの createProduct メソッドを使用して、製品 ProductA と ProductB を生成しています。createProduct メソッドは、生成する製品のタイプを引数として受け取り、適切な具体クラスのインスタンスを返します。これにより、クライアントコードは製品の具体的な生成方法を知る必要がなく、柔軟で拡張性のある設計が実現できます。

次に、ファクトリーパターンを利用した製品生成の具体的な応用例について説明します。

応用例：製品の生成

ファクトリーパターンを利用することで、製品生成の柔軟性と拡張性が向上します。このセクションでは、実際のシナリオにおいてファクトリーパターンをどのように適用できるかを具体的に示します。

シナリオ：形状オブジェクトの生成

ここでは、異なる形状オブジェクト（例：円、四角形、三角形）を生成するシナリオを考えます。各形状は共通のインターフェースを持ち、ファクトリークラスを使用して生成されます。

クラス設計

まず、形状オブジェクトのインターフェースと具体クラスを定義します。

#include <iostream>
#include <memory>

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

// 具体クラス Circle
class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

// 具体クラス Square
class Square : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Square" << std::endl;
    }
};

// 具体クラス Triangle
class Triangle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Triangle" << std::endl;
    }
};

ファクトリークラスの定義

次に、形状オブジェクトを生成するファクトリークラスを定義します。

class ShapeFactory {
public:
    enum class ShapeType {
        Circle,
        Square,
        Triangle
    };

    static std::unique_ptr<Shape> createShape(ShapeType type) {
        switch (type) {
        case ShapeType::Circle:
            return std::make_unique<Circle>();
        case ShapeType::Square:
            return std::make_unique<Square>();
        case ShapeType::Triangle:
            return std::make_unique<Triangle>();
        default:
            throw std::invalid_argument("Unknown shape type");
        }
    }
};

ファクトリーパターンの利用例

最後に、ファクトリークラスを使用して形状オブジェクトを生成し、利用する例を示します。

int main() {
    // Circleを生成
    auto circle = ShapeFactory::createShape(ShapeFactory::ShapeType::Circle);
    circle->draw();  // 出力: Drawing Circle

    // Squareを生成
    auto square = ShapeFactory::createShape(ShapeFactory::ShapeType::Square);
    square->draw();  // 出力: Drawing Square

    // Triangleを生成
    auto triangle = ShapeFactory::createShape(ShapeFactory::ShapeType::Triangle);
    triangle->draw();  // 出力: Drawing Triangle

    return 0;
}

この例では、ShapeFactory クラスの createShape メソッドを使用して、異なる形状オブジェクトを生成しています。各形状オブジェクトは共通のインターフェースを実装しているため、クライアントコードは生成されたオブジェクトを同じ方法で操作できます。このようにして、ファクトリーパターンを利用することで、コードの柔軟性と拡張性を高めることができます。

次に、仮想関数を使ったファクトリーパターンの応用例について説明します。

仮想関数を使った応用例

仮想関数を使用したファクトリーパターンは、動的なポリモーフィズムを活用して、さらに柔軟で拡張性の高い設計を実現します。このセクションでは、仮想関数を用いたファクトリーパターンの応用例を具体的に示します。

シナリオ：動的に変化する製品生成

ここでは、特定の条件に基づいて動的に製品を生成するシナリオを考えます。たとえば、ユーザー入力や設定に応じて異なる形状オブジェクトを生成します。

クラス設計

仮想関数を用いた製品生成のために、基底クラスと派生クラスを定義します。

#include <iostream>
#include <memory>

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

// 具体クラス Circle
class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

// 具体クラス Square
class Square : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Square" << std::endl;
    }
};

// 具体クラス Triangle
class Triangle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Triangle" << std::endl;
    }
};

// 抽象クラス ShapeFactory
class ShapeFactory {
public:
    virtual std::unique_ptr<Shape> createShape() const = 0;
    virtual ~ShapeFactory() = default;
};

// 具体クラス CircleFactory
class CircleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Circle>();
    }
};

// 具体クラス SquareFactory
class SquareFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Square>();
    }
};

// 具体クラス TriangleFactory
class TriangleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Triangle>();
    }
};

ファクトリーパターンの利用例

次に、動的にファクトリークラスを選択し、形状オブジェクトを生成する例を示します。

void drawShape(const ShapeFactory& factory) {
    auto shape = factory.createShape();
    shape->draw();
}

int main() {
    CircleFactory circleFactory;
    SquareFactory squareFactory;
    TriangleFactory triangleFactory;

    drawShape(circleFactory);  // 出力: Drawing Circle
    drawShape(squareFactory);  // 出力: Drawing Square
    drawShape(triangleFactory);  // 出力: Drawing Triangle

    return 0;
}

この例では、ShapeFactory クラスの派生クラスを使用して、動的に異なる形状オブジェクトを生成しています。drawShape 関数は、任意の ShapeFactory を受け取り、そのファクトリーを使用して形状オブジェクトを生成し、描画します。これにより、動的に異なる製品を生成する柔軟な設計が可能になります。

次に、ファクトリーパターン実装後のテストとデバッグの方法について説明します。

テストとデバッグの方法

ファクトリーパターンを実装した後、コードの正確性と信頼性を確保するためにテストとデバッグが不可欠です。このセクションでは、ファクトリーパターンの実装に対する効果的なテストとデバッグの方法について説明します。

単体テストの重要性

単体テスト（ユニットテスト）は、個々のクラスやメソッドが期待通りに動作することを確認するためのテスト手法です。ファクトリーパターンにおいても、各ファクトリーメソッドや生成されたオブジェクトの動作を検証するために単体テストが重要です。

テストケースの作成

以下のように、ShapeFactory クラスとその派生クラスに対する単体テストを作成します。ここでは、Google Testフレームワークを使用した例を示します。

#include <gtest/gtest.h>

// テスト対象クラスのインクルード
#include "shape_factory.h"

// CircleFactoryのテスト
TEST(ShapeFactoryTest, CreateCircle) {
    CircleFactory circleFactory;
    auto shape = circleFactory.createShape();
    ASSERT_TRUE(dynamic_cast<Circle*>(shape.get()) != nullptr);
}

// SquareFactoryのテスト
TEST(ShapeFactoryTest, CreateSquare) {
    SquareFactory squareFactory;
    auto shape = squareFactory.createShape();
    ASSERT_TRUE(dynamic_cast<Square*>(shape.get()) != nullptr);
}

// TriangleFactoryのテスト
TEST(ShapeFactoryTest, CreateTriangle) {
    TriangleFactory triangleFactory;
    auto shape = triangleFactory.createShape();
    ASSERT_TRUE(dynamic_cast<Triangle*>(shape.get()) != nullptr);
}

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

このテストコードは、各ファクトリークラスが正しく対応する形状オブジェクトを生成することを確認します。Google Testフレームワークを使用して、テストを実行します。

デバッグのポイント

ファクトリーパターンのデバッグにおいて、以下のポイントに注意します：

  • オブジェクト生成の検証: ファクトリーメソッドが正しいオブジェクトを生成しているか確認します。生成されたオブジェクトの型やメソッドの動作を検証します。
  • エラーハンドリング: ファクトリーメソッド内で不正な引数や不明な型が指定された場合のエラーハンドリングを確認します。例外処理やエラーメッセージの適切性を確認します。
  • メモリリークの検出: 動的に生成されたオブジェクトのメモリリークがないことを確認します。スマートポインタ（例：std::unique_ptr）を使用して、メモリ管理を適切に行います。

デバッグツールの活用

C++のデバッグには、以下のツールを活用します：

  • GDB（GNU Debugger）: プログラムの実行をステップ実行し、変数の値を確認したり、ブレークポイントを設定してプログラムの動作を詳細に調査します。
  • Valgrind: メモリリークやメモリエラーを検出するためのツールです。ファクトリーパターン実装後のメモリ管理の確認に役立ちます。

次に、実装したファクトリーパターンのコードを最適化するためのポイントについて説明します。

コードの最適化

ファクトリーパターンを実装した後、コードのパフォーマンスと可読性を向上させるために最適化が必要です。このセクションでは、ファクトリーパターンのコードを最適化するための具体的なポイントについて説明します。

コードの簡素化

コードを簡素化することで、可読性と保守性が向上します。例えば、条件分岐を減らすために、ファクトリーメソッドの中で利用するオブジェクト生成のロジックを工夫することが重要です。

class ShapeFactory {
public:
    enum class ShapeType {
        Circle,
        Square,
        Triangle
    };

    static std::unique_ptr<Shape> createShape(ShapeType type) {
        switch (type) {
        case ShapeType::Circle:
            return std::make_unique<Circle>();
        case ShapeType::Square:
            return std::make_unique<Square>();
        case ShapeType::Triangle:
            return std::make_unique<Triangle>();
        default:
            throw std::invalid_argument("Unknown shape type");
        }
    }
};

このコードでは、条件分岐を最小限に抑え、各ケースで適切なオブジェクトを生成しています。

スマートポインタの使用

C++11以降では、スマートポインタ（例：std::unique_ptrやstd::shared_ptr）を使用することで、メモリ管理を自動化し、メモリリークを防ぎます。以下は、スマートポインタを使用したコード例です。

static std::unique_ptr<Shape> createShape(ShapeType type) {
    switch (type) {
    case ShapeType::Circle:
        return std::make_unique<Circle>();
    case ShapeType::Square:
        return std::make_unique<Square>();
    case ShapeType::Triangle:
        return std::make_unique<Triangle>();
    default:
        throw std::invalid_argument("Unknown shape type");
    }
}

スマートポインタを使用することで、手動でのメモリ解放が不要になり、コードが簡潔になります。

設計の見直し

ファクトリーパターンの設計を見直し、クラスの責務を明確にすることも最適化の一環です。例えば、オブジェクト生成のロジックが複雑になる場合は、生成ロジックを別のクラスに委譲することで、コードの責務分担が明確になります。

class ShapeFactory {
public:
    virtual std::unique_ptr<Shape> createShape() const = 0;
};

class CircleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Circle>();
    }
};

// 他の具体的なファクトリークラスも同様に定義

このようにすることで、各具体的なファクトリークラスは特定のオブジェクト生成に専念し、コードの可読性と保守性が向上します。

パフォーマンスの向上

コードのパフォーマンスを向上させるためには、以下のポイントに注意します：

  • 無駄なオブジェクト生成の回避: 不要なオブジェクト生成を避け、必要なときにのみ生成するようにします。
  • 効率的なアルゴリズムの選択: オブジェクト生成や管理の際に効率的なアルゴリズムを選択します。

次に、読者が実際に試すことができる演習問題を提供します。

実践演習

ここでは、ファクトリーパターンと仮想関数を利用した実践的な演習問題を提供します。これにより、読者は学んだ知識を実際に試して理解を深めることができます。

演習問題 1: 新しい形状クラスの追加

以下の手順に従って、新しい形状クラス Rectangle を追加し、ファクトリーパターンに組み込みましょう。

  1. 抽象クラス Shape を継承する Rectangle クラスを定義し、draw メソッドを実装します。
  2. ShapeFactory に RectangleFactory クラスを追加し、Rectangle オブジェクトを生成するファクトリーメソッドを実装します。
  3. main 関数にて、Rectangle オブジェクトを生成し、その draw メソッドを呼び出して動作を確認します。
#include <iostream>
#include <memory>

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

// 具体クラス Circle
class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

// 具体クラス Square
class Square : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Square" << std::endl;
    }
};

// 具体クラス Triangle
class Triangle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Triangle" << std::endl;
    }
};

// 新しい具体クラス Rectangle
class Rectangle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing Rectangle" << std::endl;
    }
};

// 抽象クラス ShapeFactory
class ShapeFactory {
public:
    virtual std::unique_ptr<Shape> createShape() const = 0;
    virtual ~ShapeFactory() = default;
};

// 具体クラス CircleFactory
class CircleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Circle>();
    }
};

// 具体クラス SquareFactory
class SquareFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Square>();
    }
};

// 具体クラス TriangleFactory
class TriangleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Triangle>();
    }
};

// 新しい具体クラス RectangleFactory
class RectangleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape() const override {
        return std::make_unique<Rectangle>();
    }
};

void drawShape(const ShapeFactory& factory) {
    auto shape = factory.createShape();
    shape->draw();
}

int main() {
    CircleFactory circleFactory;
    SquareFactory squareFactory;
    TriangleFactory triangleFactory;
    RectangleFactory rectangleFactory;

    drawShape(circleFactory);   // 出力: Drawing Circle
    drawShape(squareFactory);   // 出力: Drawing Square
    drawShape(triangleFactory); // 出力: Drawing Triangle
    drawShape(rectangleFactory); // 出力: Drawing Rectangle

    return 0;
}

演習問題 2: ファクトリーパターンの拡張

次に、さらに複雑な形状オブジェクトを生成するためにファクトリーパターンを拡張しましょう。

  1. Shape クラスに色（color）とサイズ（size）の属性を追加します。
  2. ShapeFactory クラスを拡張して、色とサイズを設定できるようにします。
  3. main 関数で異なる色とサイズの形状オブジェクトを生成し、その属性を表示するメソッドを実装します。
// 形状クラスに color と size 属性を追加
class Shape {
public:
    virtual void draw() const = 0;
    void setColor(const std::string& c) { color = c; }
    void setSize(int s) { size = s; }
    std::string getColor() const { return color; }
    int getSize() const { return size; }
    virtual ~Shape() = default;

private:
    std::string color;
    int size;
};

// 他の形状クラス（Circle, Square, Triangle, Rectangle）も同様に変更

// ShapeFactory を拡張して、色とサイズを設定できるようにする
class ShapeFactory {
public:
    virtual std::unique_ptr<Shape> createShape(const std::string& color, int size) const = 0;
    virtual ~ShapeFactory() = default;
};

class CircleFactory : public ShapeFactory {
public:
    std::unique_ptr<Shape> createShape(const std::string& color, int size) const override {
        auto shape = std::make_unique<Circle>();
        shape->setColor(color);
        shape->setSize(size);
        return shape;
    }
};

// 他のファクトリークラス（SquareFactory, TriangleFactory, RectangleFactory）も同様に変更

void drawShape(const ShapeFactory& factory, const std::string& color, int size) {
    auto shape = factory.createShape(color, size);
    std::cout << "Shape: " << typeid(*shape).name() << ", Color: " << shape->getColor() << ", Size: " << shape->getSize() << std::endl;
    shape->draw();
}

int main() {
    CircleFactory circleFactory;
    SquareFactory squareFactory;
    TriangleFactory triangleFactory;
    RectangleFactory rectangleFactory;

    drawShape(circleFactory, "Red", 5);   // 出力: Circle, Red, 5
    drawShape(squareFactory, "Blue", 10); // 出力: Square, Blue, 10
    drawShape(triangleFactory, "Green", 7); // 出力: Triangle, Green, 7
    drawShape(rectangleFactory, "Yellow", 12); // 出力: Rectangle, Yellow, 12

    return 0;
}

この演習問題により、読者はファクトリーパターンの柔軟性を理解し、異なる属性を持つオブジェクトを動的に生成する方法を学ぶことができます。

次に、本記事のまとめに進みます。

まとめ

本記事では、C++の仮想関数を用いたファクトリーパターンの実装と応用例について詳しく解説しました。仮想関数の基本概念から始まり、デザインパターンの重要性、ファクトリーパターンの概要とその利点について説明しました。さらに、具体的な実装例や応用例を通じて、ファクトリーパターンの実際の利用方法とその柔軟性を示しました。

仮想関数とファクトリーパターンを組み合わせることで、コードの再利用性と保守性を向上させ、異なるクラス間での一貫性を保つことができます。実践演習を通じて、読者はこれらの概念を深く理解し、実際のプロジェクトに適用できるスキルを身につけることができたでしょう。

これらの知識を活用して、今後の開発において柔軟で拡張性のある設計を目指してください。

C++
デザインパターン ファクトリーパターン C++ 仮想関数

コメント

コメントする

目次