【C++入門】継承の使い方完全マスター！実践で役立つ7つの設計パターン

C++の継承とは？初心者にもわかる基礎解説

オブジェクト指向の重要な柱となる継承の本質

継承は、オブジェクト指向プログラミングの中核を成す重要な機能です。既存のクラス（基底クラス）の特徴や機能を新しいクラス（派生クラス）に引き継ぎ、コードの再利用性と保守性を高めることができます。

以下の例で、継承の基本的な概念を見てみましょう：

// 基底クラス：動物の基本的な特徴を定義
class Animal {
protected:
    std::string name;
    int age;

public:
    Animal(const std::string& n, int a) : name(n), age(a) {}

    virtual void makeSound() {
        std::cout << "何かの音を出す" << std::endl;
    }

    void showInfo() {
        std::cout << "名前: " << name << ", 年齢: " << age << std::endl;
    }
};

// 派生クラス：犬の特徴を定義
class Dog : public Animal {
private:
    std::string breed;  // 犬種

public:
    Dog(const std::string& n, int a, const std::string& b)
        : Animal(n, a), breed(b) {}

    // 基底クラスのメソッドをオーバーライド
    void makeSound() override {
        std::cout << "ワン！ワン！" << std::endl;
    }
};

このコード例では、Animalクラスの機能をDogクラスが継承しており、以下のような特徴が見られます：

1. コードの再利用：nameやageなどの共通属性を再定義する必要がない
2. 機能の拡張：breedという犬特有の属性を追加
3. 振る舞いの特殊化：makeSound()メソッドを犬用にオーバーライド

継承によって実現できる3つのメリット

1. コードの再利用性向上

既存クラスの機能を活用することで、開発効率が大幅に向上します。例えば、上記の例ではAnimalクラスのshowInfo()メソッドをDogクラスが自動的に利用できます。

Dog myDog("ポチ", 3, "柴犬");
myDog.showInfo();  // Animal クラスのメソッドを継承して使用

2. 保守性の向上

共通機能を基底クラスにまとめることで、修正が必要な際の影響範囲を限定できます。例えば、全ての動物に共通する新機能を追加する場合：

class Animal {
    // 既存のメンバー...

    // 全ての動物に体重を追加
    void addWeight(double w) {
        weight = w;
        updateHealthStatus();  // 健康状態の更新
    }
};

この変更は、全ての派生クラスに自動的に反映されます。

3. 多態性の実現

同じインターフェースで異なる実装を提供できる多態性により、柔軟なプログラム設計が可能になります：

// 動物の配列で異なる種類の動物を管理
std::vector<Animal*> animals;
animals.push_back(new Dog("ポチ", 3, "柴犬"));
animals.push_back(new Cat("タマ", 2));  // 別の派生クラス

// 各動物の鳴き声を出す（多態性の活用）
for (auto animal : animals) {
    animal->makeSound();  // それぞれの動物が適切な鳴き声を出す
}

このように、継承を使用することで、コードの再利用性、保守性、拡張性が向上し、より柔軟なプログラム設計が可能になります。次のセクションでは、これらの機能をより効果的に活用するための具体的な実装方法について詳しく見ていきましょう。

C++における継承の基本文法と実装方法

publicとprivateとprotected継承の違いと使い分け

C++では継承時のアクセス指定子によって、基底クラスのメンバーが派生クラスでどのように扱われるかが決定されます。以下で各種類の特徴と使い分けを説明します。

1. public継承

最も一般的な継承方法で、「is-a」関係を表現する際に使用します。

class Base {
public:
    void publicMethod() { /* ... */ }
protected:
    void protectedMethod() { /* ... */ }
private:
    void privateMethod() { /* ... */ }
};

class Derived : public Base {  // public継承
    void someMethod() {
        publicMethod();      // OK: publicはpublicのまま
        protectedMethod();   // OK: protectedはprotectedのまま
        // privateMethod(); // エラー: privateにはアクセス不可
    }
};

int main() {
    Derived d;
    d.publicMethod();  // OK: publicメソッドは外部からアクセス可能
}

2. protected継承

基底クラスの機能を派生クラスでのみ使用し、外部には公開したくない場合に使用します。

class Derived2 : protected Base {
    void someMethod() {
        publicMethod();      // OK: publicはprotectedになる
        protectedMethod();   // OK: protectedはprotectedのまま
        // privateMethod(); // エラー: privateにはアクセス不可
    }
};

int main() {
    Derived2 d;
    // d.publicMethod();  // エラー: protectedメソッドは外部からアクセス不可
}

3. private継承

実装の再利用が目的で、継承関係を外部に公開したくない場合に使用します。

class Derived3 : private Base {
    void someMethod() {
        publicMethod();      // OK: publicはprivateになる
        protectedMethod();   // OK: protectedはprivateになる
        // privateMethod(); // エラー: privateにはアクセス不可
    }
};

class Further : public Derived3 {
    void anotherMethod() {
        // publicMethod();    // エラー: 基底クラスのメソッドにアクセス不可
    }
};

virtualキーワードの重要性と適切な使用方法

virtualキーワードは、C++で多態性を実現するための重要な機能です。以下の例で、その重要性を説明します。

1. 基本的な使用方法

class Shape {
public:
    // virtualキーワードにより、派生クラスでオーバーライド可能に
    virtual double calculateArea() const {
        return 0.0;
    }

    // 派生クラスでデストラクタが正しく呼ばれるようにvirtualを指定
    virtual ~Shape() = default;
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // override指定で意図的なオーバーライドであることを明示
    double calculateArea() const override {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
private:
    double width;
    double height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    double calculateArea() const override {
        return width * height;
    }
};

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

class AbstractShape {
public:
    // 純粋仮想関数の定義
    virtual double calculateArea() const = 0;
    virtual double calculatePerimeter() const = 0;

    virtual ~AbstractShape() = default;
};

class Square : public AbstractShape {
private:
    double side;

public:
    Square(double s) : side(s) {}

    // 純粋仮想関数の実装が必須
    double calculateArea() const override {
        return side * side;
    }

    double calculatePerimeter() const override {
        return 4 * side;
    }
};

3. virtualの使用における注意点

1. パフォーマンスへの影響:

// 仮想関数テーブル（vtable）のオーバーヘッドが発生
class Base {
    virtual void method() {} // vtableポインタが追加される
};

2. コンストラクタでの使用制限:

class Base {
public:
    Base() {
        initialize();  // 派生クラスのオーバーライドバージョンは呼ばれない
    }
    virtual void initialize() { /* ... */ }
};

3. virtual継承によるダイヤモンド問題の解決:

class A { /* ... */ };
class B : virtual public A { /* ... */ };
class C : virtual public A { /* ... */ };
class D : public B, public C { /* ... */ };  // Aは一度だけ継承される

これらの機能を適切に使用することで、柔軟で保守性の高いコードを設計することができます。次のセクションでは、これらの基本的な概念を活用した実践的な設計パターンについて説明していきます。

実践で使える継承の設計パターン

Template Methodパターンによる共通処理の抽象化

Template Methodパターンは、アルゴリズムの骨格を基底クラスで定義し、具体的な実装を派生クラスで行うデザインパターンです。

// ドキュメント処理の基底クラス
class DocumentProcessor {
protected:
    // 派生クラスで実装される具体的な処理
    virtual void readDocument() = 0;
    virtual void parseContent() = 0;
    virtual void validateContent() = 0;
    virtual void saveDocument() = 0;

public:
    // テンプレートメソッド：処理の流れを定義
    void processDocument() {
        readDocument();
        parseContent();
        validateContent();
        saveDocument();
        std::cout << "ドキュメント処理完了" << std::endl;
    }

    virtual ~DocumentProcessor() = default;
};

// PDF文書処理クラス
class PDFProcessor : public DocumentProcessor {
protected:
    void readDocument() override {
        std::cout << "PDFファイルを読み込み" << std::endl;
    }

    void parseContent() override {
        std::cout << "PDF内容を解析" << std::endl;
    }

    void validateContent() override {
        std::cout << "PDF形式を検証" << std::endl;
    }

    void saveDocument() override {
        std::cout << "処理済みPDFを保存" << std::endl;
    }
};

使用例：

void processDocuments() {
    PDFProcessor pdfProc;
    pdfProc.processDocument();  // 定義された順序で処理が実行される
}

Strategyパターンを用いたアルゴリズムの切り替え

Strategyパターンでは、アルゴリズムを動的に切り替えることができます。これにより、クライアントコードを変更することなく、異なる実装を使用できます。

// 圧縮アルゴリズムのインターフェース
class CompressionStrategy {
public:
    virtual void compress(const std::string& data) = 0;
    virtual ~CompressionStrategy() = default;
};

// 具体的な圧縮アルゴリズム実装
class ZipCompression : public CompressionStrategy {
public:
    void compress(const std::string& data) override {
        std::cout << "ZIPで圧縮: " << data << std::endl;
    }
};

class GzipCompression : public CompressionStrategy {
public:
    void compress(const std::string& data) override {
        std::cout << "GZIPで圧縮: " << data << std::endl;
    }
};

// 圧縮を使用するクラス
class FileCompressor {
private:
    std::unique_ptr<CompressionStrategy> strategy;

public:
    FileCompressor(std::unique_ptr<CompressionStrategy> s)
        : strategy(std::move(s)) {}

    void setStrategy(std::unique_ptr<CompressionStrategy> s) {
        strategy = std::move(s);
    }

    void compress(const std::string& data) {
        strategy->compress(data);
    }
};

使用例：

void compressFiles() {
    FileCompressor compressor(std::make_unique<ZipCompression>());
    compressor.compress("sample.txt");  // ZIPで圧縮

    // 圧縮方式を動的に切り替え
    compressor.setStrategy(std::make_unique<GzipCompression>());
    compressor.compress("sample.txt");  // GZIPで圧縮
}

Bridgeパターンによる実装の分離

Bridgeパターンは、抽象部分と実装部分を分離し、それぞれを独立して変更可能にするパターンです。

// 実装部分のインターフェース
class DrawingAPI {
public:
    virtual void drawCircle(double x, double y, double radius) = 0;
    virtual ~DrawingAPI() = default;
};

// 具体的な実装（OpenGL）
class OpenGLAPI : public DrawingAPI {
public:
    void drawCircle(double x, double y, double radius) override {
        std::cout << "OpenGLで円を描画: (" << x << "," << y 
                  << "), 半径=" << radius << std::endl;
    }
};

// 具体的な実装（Direct3D）
class Direct3DAPI : public DrawingAPI {
public:
    void drawCircle(double x, double y, double radius) override {
        std::cout << "Direct3Dで円を描画: (" << x << "," << y 
                  << "), 半径=" << radius << std::endl;
    }
};

// 抽象部分の基底クラス
class Shape {
protected:
    DrawingAPI* api;

public:
    Shape(DrawingAPI* drawingAPI) : api(drawingAPI) {}
    virtual void draw() = 0;
    virtual void resizeByPercentage(double pct) = 0;
    virtual ~Shape() = default;
};

// 具体的な図形クラス
class Circle : public Shape {
private:
    double x, y, radius;

public:
    Circle(double x, double y, double radius, DrawingAPI* drawingAPI)
        : Shape(drawingAPI), x(x), y(y), radius(radius) {}

    void draw() override {
        api->drawCircle(x, y, radius);
    }

    void resizeByPercentage(double pct) override {
        radius *= pct / 100.0;
    }
};

使用例：

void drawShapes() {
    OpenGLAPI opengl;
    Direct3DAPI direct3d;

    Circle circleGL(1, 2, 3, &opengl);
    Circle circleD3D(4, 5, 6, &direct3d);

    circleGL.draw();    // OpenGLで描画
    circleD3D.draw();   // Direct3Dで描画

    circleGL.resizeByPercentage(150);  // サイズ変更
    circleGL.draw();    // 変更後のサイズで描画
}

これらのデザインパターンを適切に使用することで、以下のような利点が得られます：

1. コードの再利用性が向上
2. 機能の追加・変更が容易
3. テストが書きやすくなる
4. コードの見通しが良くなる

実際のプロジェクトでは、これらのパターンを組み合わせて使用することも多く、状況に応じて最適なパターンを選択することが重要です。

継承における注意点と代替手段

多重継承が引き起こす問題とその解決策

多重継承は強力な機能ですが、適切に使用しないと深刻な問題を引き起こす可能性があります。以下で主な問題点とその解決策を説明します。

1. ダイヤモンド問題

class Device {
protected:
    std::string deviceId;
public:
    Device(const std::string& id) : deviceId(id) {}
    virtual void initialize() {
        std::cout << "Device " << deviceId << " initialized" << std::endl;
    }
};

// 問題のある実装例
class Printer : public Device {
public:
    Printer(const std::string& id) : Device(id) {}
};

class Scanner : public Device {
public:
    Scanner(const std::string& id) : Device(id) {}
};

class MultiFunctionPrinter : public Printer, public Scanner {
public:
    // コンパイルエラー：Deviceのメンバーが曖昧
    MultiFunctionPrinter(const std::string& id) 
        : Printer(id), Scanner(id) {}
};

解決策：仮想継承の使用

class Printer : virtual public Device {
public:
    Printer(const std::string& id) : Device(id) {}
};

class Scanner : virtual public Device {
public:
    Scanner(const std::string& id) : Device(id) {}
};

class MultiFunctionPrinter : public Printer, public Scanner {
public:
    // 正しく動作する実装
    MultiFunctionPrinter(const std::string& id) 
        : Device(id), Printer(id), Scanner(id) {}
};

2. 名前の衝突問題

class AudioDevice {
public:
    virtual void process() {
        std::cout << "Audio processing" << std::endl;
    }
};

class VideoDevice {
public:
    virtual void process() {
        std::cout << "Video processing" << std::endl;
    }
};

class MediaPlayer : public AudioDevice, public VideoDevice {
public:
    // 曖昧さを解消するための明示的な指定が必要
    void process() {
        AudioDevice::process();
        VideoDevice::process();
    }
};

継承の代わりにコンポジションを使うべき場面

コンポジションは「has-a」関係を表現する方法で、以下のような場合に継承よりも適切な選択となります：

1. 実行時に振る舞いを変更する必要がある場合
2. 基底クラスの実装詳細から派生クラスを保護したい場合
3. 複数のクラスの機能を組み合わせる必要がある場合

コンポジションの実装例

// 継承を使用した場合の問題のある実装
class Logger {
public:
    virtual void log(const std::string& message) = 0;
};

class FileLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::cout << "File: " << message << std::endl;
    }
};

class DatabaseLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::cout << "DB: " << message << std::endl;
    }
};

// 複数のログ出力が必要な場合、多重継承が必要になる
class MultiLogger : public FileLogger, public DatabaseLogger {
    // 実装が複雑になる...
};

コンポジションを使用した改善例

class Logger {
public:
    virtual void log(const std::string& message) = 0;
    virtual ~Logger() = default;
};

class FileLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::cout << "File: " << message << std::endl;
    }
};

class DatabaseLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::cout << "DB: " << message << std::endl;
    }
};

// コンポジションを使用した実装
class LoggingSystem {
private:
    std::vector<std::unique_ptr<Logger>> loggers;

public:
    void addLogger(std::unique_ptr<Logger> logger) {
        loggers.push_back(std::move(logger));
    }

    void log(const std::string& message) {
        for (const auto& logger : loggers) {
            logger->log(message);
        }
    }
};

使用例：

void demonstrateLogging() {
    LoggingSystem loggingSystem;

    loggingSystem.addLogger(std::make_unique<FileLogger>());
    loggingSystem.addLogger(std::make_unique<DatabaseLogger>());

    loggingSystem.log("テストメッセージ");  // 両方のロガーで記録
}

コンポジションを使用することで得られる利点：

1. 柔軟性の向上

• 実行時に動的にロガーを追加・削除可能
• 新しいロガータイプの追加が容易

1. カプセル化の強化

• 内部実装の詳細を隠蔽
• インターフェースの変更による影響を最小限に抑制

1. テスト容易性

• モックオブジェクトの作成が容易
• 個々のコンポーネントを独立してテスト可能

1. 保守性の向上

• コードの依存関係が明確
• 機能の追加・変更が容易

これらの設計選択を適切に行うことで、より保守性が高く、柔軟なコードを作成することができます。

現場で活きる継承の実践的な使用例

GUIフレームワークにおける継承の活用

GUIフレームワークでは、ウィジェットの階層構造を表現するために継承が効果的に使用されています。以下に実践的な例を示します。

// 基本的なウィジェットクラス
class Widget {
protected:
    int x, y, width, height;
    bool visible;

public:
    Widget(int x, int y, int w, int h)
        : x(x), y(y), width(w), height(h), visible(true) {}

    virtual void draw() = 0;
    virtual void handleEvent(const Event& event) = 0;
    virtual bool containsPoint(int px, int py) {
        return px >= x && px < x + width &&
               py >= y && py < y + height;
    }

    virtual ~Widget() = default;
};

// ボタンウィジェット
class Button : public Widget {
private:
    std::string label;
    std::function<void()> onClick;

public:
    Button(int x, int y, int w, int h, const std::string& text)
        : Widget(x, y, w, h), label(text) {}

    void draw() override {
        std::cout << "描画: " << label << " ボタン at (" 
                  << x << "," << y << ")" << std::endl;
    }

    void handleEvent(const Event& event) override {
        if (event.type == EventType::CLICK && containsPoint(event.x, event.y)) {
            if (onClick) onClick();
        }
    }

    void setOnClick(std::function<void()> handler) {
        onClick = handler;
    }
};

// テキストフィールドウィジェット
class TextField : public Widget {
private:
    std::string text;
    bool focused;

public:
    TextField(int x, int y, int w, int h)
        : Widget(x, y, w, h), focused(false) {}

    void draw() override {
        std::cout << "描画: テキストフィールド \"" << text 
                  << "\" at (" << x << "," << y << ")" << std::endl;
    }

    void handleEvent(const Event& event) override {
        if (event.type == EventType::CLICK) {
            focused = containsPoint(event.x, event.y);
        } else if (event.type == EventType::KEY && focused) {
            text += event.key;
        }
    }
};

ゲーム開発での継承を用いたキャラクター設計

ゲーム開発では、キャラクターの種類や振る舞いを効率的に管理するために継承が活用されます。

// ゲームエンティティの基底クラス
class GameObject {
protected:
    Vector2D position;
    float rotation;
    bool active;

public:
    GameObject(const Vector2D& pos)
        : position(pos), rotation(0.0f), active(true) {}

    virtual void update(float deltaTime) = 0;
    virtual void render() = 0;
    virtual void onCollision(GameObject* other) = 0;

    virtual ~GameObject() = default;
};

// キャラクターの基底クラス
class Character : public GameObject {
protected:
    float health;
    float speed;
    std::string name;

public:
    Character(const Vector2D& pos, float maxHealth, float moveSpeed)
        : GameObject(pos), health(maxHealth), speed(moveSpeed) {}

    virtual void takeDamage(float amount) {
        health = std::max(0.0f, health - amount);
        if (health <= 0) {
            onDeath();
        }
    }

    virtual void onDeath() = 0;
};

// プレイヤーキャラクター
class Player : public Character {
private:
    Inventory inventory;
    std::vector<Skill> skills;

public:
    Player(const Vector2D& pos)
        : Character(pos, 100.0f, 5.0f) {}

    void update(float deltaTime) override {
        // プレイヤーの入力処理
        handleInput();
        // 位置の更新
        updatePosition(deltaTime);
        // スキルのクールダウン更新
        updateSkillCooldowns(deltaTime);
    }

    void render() override {
        std::cout << "プレイヤーの描画 at " << position.toString() << std::endl;
        renderHealthBar();
        renderInventory();
    }

    void onCollision(GameObject* other) override {
        if (auto* item = dynamic_cast<Item*>(other)) {
            inventory.addItem(item);
        } else if (auto* enemy = dynamic_cast<Enemy*>(other)) {
            takeDamage(enemy->getDamage());
        }
    }

    void onDeath() override {
        std::cout << "ゲームオーバー" << std::endl;
        // リスポーン処理
        respawn();
    }
};

// 敵キャラクター
class Enemy : public Character {
private:
    float detectionRange;
    AIController aiController;

public:
    Enemy(const Vector2D& pos, float health, float speed, float range)
        : Character(pos, health, speed), detectionRange(range) {}

    void update(float deltaTime) override {
        // AI行動の更新
        aiController.update(deltaTime);
        // パトロールや追跡の処理
        updateBehavior();
        // 位置の更新
        updatePosition(deltaTime);
    }

    void render() override {
        std::cout << "敵の描画 at " << position.toString() << std::endl;
        renderHealthBar();
    }

    void onCollision(GameObject* other) override {
        if (auto* player = dynamic_cast<Player*>(other)) {
            performAttack(player);
        }
    }

    void onDeath() override {
        // アイテムのドロップ
        dropLoot();
        // 経験値の付与
        giveExperience();
        // エンティティの削除
        destroy();
    }
};

これらの実装例から、継承を活用する際の重要なポイントが見えてきます：

1. 適切な抽象化レベルの選択

• 基底クラスでは共通の振る舞いを定義
• 具体的な実装は派生クラスに委ねる

1. インターフェースの一貫性

• 同じ基底クラスから派生したクラスは同じインターフェースを持つ
• これにより、多態性を活用した柔軟な処理が可能に

1. 拡張性の確保

• 新しい種類のウィジェットやキャラクターを追加する際に、既存のコードを変更する必要がない
• オープン・クローズドの原則に従った設計

1. 再利用可能なコード

• 共通の機能を基底クラスに実装することで、コードの重複を防ぐ
• メンテナンス性の向上につながる

これらの実践例は、継承が適切に使用された場合にもたらされる利点を具体的に示しています。

継承を用いたコードのテスト手法

モック作成における継承の活用方法

テスト時には、外部依存性を持つクラスをテストするために、モックオブジェクトを作成する必要があります。継承を使用することで、効果的なモックの作成が可能になります。

// データベース接続の抽象基底クラス
class DatabaseConnection {
public:
    virtual bool connect(const std::string& connectionString) = 0;
    virtual bool execute(const std::string& query) = 0;
    virtual std::vector<std::string> fetchResults() = 0;
    virtual void disconnect() = 0;
    virtual ~DatabaseConnection() = default;
};

// 実際のデータベース接続クラス
class RealDatabaseConnection : public DatabaseConnection {
public:
    bool connect(const std::string& connectionString) override {
        // 実際のデータベース接続処理
        return true;
    }

    bool execute(const std::string& query) override {
        // 実際のクエリ実行処理
        return true;
    }

    std::vector<std::string> fetchResults() override {
        // 実際の結果取得処理
        return std::vector<std::string>();
    }

    void disconnect() override {
        // 実際の切断処理
    }
};

// テスト用モッククラス
class MockDatabaseConnection : public DatabaseConnection {
private:
    bool shouldConnectSucceed = true;
    bool shouldExecuteSucceed = true;
    std::vector<std::string> mockResults;
    std::vector<std::string> executedQueries;

public:
    // モックの振る舞いを設定するメソッド
    void setConnectBehavior(bool succeed) {
        shouldConnectSucceed = succeed;
    }

    void setExecuteBehavior(bool succeed) {
        shouldExecuteSucceed = succeed;
    }

    void setMockResults(const std::vector<std::string>& results) {
        mockResults = results;
    }

    // 実行されたクエリを取得
    const std::vector<std::string>& getExecutedQueries() const {
        return executedQueries;
    }

    // インターフェースの実装
    bool connect(const std::string& connectionString) override {
        return shouldConnectSucceed;
    }

    bool execute(const std::string& query) override {
        executedQueries.push_back(query);
        return shouldExecuteSucceed;
    }

    std::vector<std::string> fetchResults() override {
        return mockResults;
    }

    void disconnect() override {
        // モックの切断処理
    }
};

// テスト対象のクラス
class UserRepository {
private:
    DatabaseConnection& db;

public:
    UserRepository(DatabaseConnection& connection) : db(connection) {}

    bool addUser(const std::string& username, const std::string& email) {
        std::string query = "INSERT INTO users (username, email) VALUES ('" +
                           username + "', '" + email + "')";
        return db.execute(query);
    }

    std::vector<std::string> findUsersByEmail(const std::string& email) {
        std::string query = "SELECT * FROM users WHERE email = '" + email + "'";
        db.execute(query);
        return db.fetchResults();
    }
};

// テストコード例
void testUserRepository() {
    // モックの準備
    MockDatabaseConnection mockDb;
    mockDb.setExecuteBehavior(true);
    mockDb.setMockResults({"user1", "user2"});

    // テスト対象のインスタンス作成
    UserRepository repo(mockDb);

    // テストケース1: ユーザー追加
    bool result = repo.addUser("testuser", "test@example.com");
    assert(result == true);
    assert(mockDb.getExecutedQueries().back().find("INSERT INTO users") != std::string::npos);

    // テストケース2: ユーザー検索
    auto users = repo.findUsersByEmail("test@example.com");
    assert(users.size() == 2);
    assert(users[0] == "user1");
    assert(users[1] == "user2");
}

テスタビリティを高める継承の設計方針

テスタブルなコードを書くためには、以下のような設計方針を考慮する必要があります：

1. 依存性の注入

// テスタビリティの低い設計
class BadDesign {
private:
    RealDatabaseConnection db;  // 直接具象クラスを使用

public:
    void someMethod() {
        db.execute("...");
    }
};

// テスタビリティの高い設計
class GoodDesign {
private:
    DatabaseConnection& db;  // インターフェースを使用

public:
    GoodDesign(DatabaseConnection& connection) : db(connection) {}

    void someMethod() {
        db.execute("...");
    }
};

2. protected仮想メソッドの活用

class DataProcessor {
public:
    bool processData(const std::string& data) {
        if (!validateData(data)) return false;
        return performProcessing(data);
    }

protected:
    // テストでオーバーライド可能
    virtual bool validateData(const std::string& data) {
        return !data.empty();
    }

    virtual bool performProcessing(const std::string& data) = 0;
};

// テスト用クラス
class TestableDataProcessor : public DataProcessor {
protected:
    bool validateData(const std::string& data) override {
        // カスタムバリデーションロジック
        return true;
    }

    bool performProcessing(const std::string& data) override {
        // テスト用の処理
        return true;
    }
};

3. テストダブルの階層構造

// 基本的なモック機能
class BaseMock : public DatabaseConnection {
protected:
    bool defaultReturn = true;

public:
    void setDefaultReturn(bool value) {
        defaultReturn = value;
    }
};

// 詳細な振る舞いをモック
class AdvancedMock : public BaseMock {
private:
    std::map<std::string, bool> queryResults;

public:
    void setQueryResult(const std::string& query, bool result) {
        queryResults[query] = result;
    }

    bool execute(const std::string& query) override {
        auto it = queryResults.find(query);
        return it != queryResults.end() ? it->second : defaultReturn;
    }
};

これらのテスト手法を活用することで、以下のような利点が得られます：

1. テストの信頼性向上

• 外部依存性を制御可能
• テストの再現性が高い

1. テストの保守性向上

• モックオブジェクトの再利用が可能
• テストコードの可読性が向上

1. テストカバレッジの向上

• エッジケースのテストが容易
• 異常系のテストが書きやすい

1. 開発効率の向上

• テストの実行が高速
• デバッグが容易

これらの手法を適切に組み合わせることで、効果的なテスト戦略を構築することができます。

継承を使いこなすためのベストプラクティス

LSP（リスコフの置換原則）に基づく継承の設計

リスコフの置換原則（LSP）は、基底クラスが使用されているところでは、そのサブクラスでも代用できるべきという原則です。この原則に従うことで、より堅牢なコードを設計できます。

LSPに違反する例

class Rectangle {
protected:
    int width;
    int height;

public:
    virtual void setWidth(int w) { width = w; }
    virtual void setHeight(int h) { height = h; }
    virtual int getArea() const { return width * height; }
};

class Square : public Rectangle {
public:
    // LSP違反：四角形の振る舞いを変更している
    void setWidth(int w) override {
        width = w;
        height = w;  // 正方形の性質を保つため
    }

    void setHeight(int h) override {
        height = h;
        width = h;   // 正方形の性質を保つため
    }
};

// この関数は長方形を期待している
void processRectangle(Rectangle& rect) {
    rect.setWidth(4);
    rect.setHeight(5);
    // 長方形なら面積は20のはずだが、
    // Square が渡された場合は25になってしまう
    assert(rect.getArea() == 20);  // Square の場合、失敗する
}

LSPに準拠した設計

// 形状の抽象基底クラス
class Shape {
public:
    virtual double getArea() const = 0;
    virtual ~Shape() = default;
};

class Rectangle : public Shape {
private:
    int width;
    int height;

public:
    Rectangle(int w, int h) : width(w), height(h) {}

    void setWidth(int w) { width = w; }
    void setHeight(int h) { height = h; }
    double getArea() const override { return width * height; }
};

class Square : public Shape {
private:
    int side;

public:
    explicit Square(int s) : side(s) {}

    void setSide(int s) { side = s; }
    double getArea() const override { return side * side; }
};

// 形状を処理する関数
void processShape(const Shape& shape) {
    // 形状の具体的な型に依存しない処理
    std::cout << "面積: " << shape.getArea() << std::endl;
}

将来の拡張性を考慮した継承階層の設計

拡張性の高い継承階層を設計するためには、以下のような点に注意を払う必要があります。

1. インターフェースの分離原則の適用

// 不適切な設計：多すぎる責務
class MultiPurposeDevice {
public:
    virtual void print() = 0;
    virtual void scan() = 0;
    virtual void fax() = 0;
    virtual void email() = 0;
};

// 改善された設計：インターフェースの分離
class Printer {
public:
    virtual void print() = 0;
    virtual ~Printer() = default;
};

class Scanner {
public:
    virtual void scan() = 0;
    virtual ~Scanner() = default;
};

class EmailSender {
public:
    virtual void email() = 0;
    virtual ~EmailSender() = default;
};

// 必要な機能だけを実装
class SimpleScanner : public Scanner {
public:
    void scan() override {
        std::cout << "文書をスキャン中..." << std::endl;
    }
};

class AdvancedPrinter : public Printer, public Scanner {
public:
    void print() override {
        std::cout << "文書を印刷中..." << std::endl;
    }

    void scan() override {
        std::cout << "文書をスキャン中..." << std::endl;
    }
};

2. 抽象基底クラスの適切な設計

// データ処理のための抽象基底クラス
class DataProcessor {
public:
    // 共通のインターフェース
    virtual void processData(const std::vector<double>& data) = 0;
    virtual std::string getProcessorName() const = 0;
    virtual bool isProcessingComplete() const = 0;

    // デフォルトの実装を提供
    virtual void initialize() {
        std::cout << "基本的な初期化を実行" << std::endl;
    }

    // フックメソッド
    virtual void preProcess() {}
    virtual void postProcess() {}

    virtual ~DataProcessor() = default;

protected:
    // 派生クラスで使用する共通ユーティリティ
    bool validateData(const std::vector<double>& data) {
        return !data.empty();
    }
};

// 平均値計算プロセッサ
class AverageProcessor : public DataProcessor {
private:
    double result = 0.0;
    bool completed = false;

public:
    void processData(const std::vector<double>& data) override {
        if (!validateData(data)) return;

        preProcess();

        double sum = 0.0;
        for (const auto& value : data) {
            sum += value;
        }
        result = sum / data.size();
        completed = true;

        postProcess();
    }

    std::string getProcessorName() const override {
        return "Average Processor";
    }

    bool isProcessingComplete() const override {
        return completed;
    }

protected:
    void preProcess() override {
        std::cout << "平均値計算の前処理" << std::endl;
    }
};

3. テンプレートメソッドパターンの活用

class ReportGenerator {
public:
    // テンプレートメソッド
    void generateReport() {
        loadData();
        validateData();
        processData();
        formatOutput();
        if (shouldSendNotification()) {
            sendNotification();
        }
    }

    virtual ~ReportGenerator() = default;

protected:
    virtual void loadData() = 0;
    virtual void validateData() = 0;
    virtual void processData() = 0;
    virtual void formatOutput() = 0;

    // フックメソッド
    virtual bool shouldSendNotification() {
        return false;
    }

    virtual void sendNotification() {
        std::cout << "通知を送信" << std::endl;
    }
};

class SalesReportGenerator : public ReportGenerator {
protected:
    void loadData() override {
        std::cout << "売上データを読み込み" << std::endl;
    }

    void validateData() override {
        std::cout << "売上データを検証" << std::endl;
    }

    void processData() override {
        std::cout << "売上データを集計" << std::endl;
    }

    void formatOutput() override {
        std::cout << "売上レポートを作成" << std::endl;
    }

    bool shouldSendNotification() override {
        return true;  // 売上レポートは常に通知を送信
    }
};

これらのベストプラクティスを適用する際の重要なポイント：

1. 設計の一貫性

• 基底クラスの契約を守る
• 派生クラスで予期せぬ振る舞いを追加しない

1. 拡張性と保守性

• 将来の要件変更を考慮した設計
• 共通コードの重複を避ける

1. カプセル化の維持

• 実装の詳細を適切に隠蔽
• インターフェースの安定性を確保

1. テスタビリティの確保

• モック化可能な設計
• 依存性の明確な分離

これらの原則に従うことで、より保守性が高く、拡張しやすいコードを設計することができます。