23：エラー処理と例外（try, throw, catch）

はじめに

ざっくり説明

• 例外とは: 「いわゆるエラー」。正常の前提が壊れたことを言語機能で上位に知らせる合図です。 例：通常 外：そうでない 通常ではない出来事、エラーを「例外」exceptionと呼びます。
• 目的: 異常を通常処理から切り離し、安全に中断・切替・記録する。

例外対処例

// 23_intro_quick.cpp
#include <iostream>
#include <stdexcept>
using namespace std;

int divi(int a, int b)
{
    if (b == 0)
    {
        throw runtime_error("0で割れない");
    }
    return a / b;
}

int main(void)
{
    try
    {
        cout << divi(10, 2) << endl;
        cout << divi(5, 0) << endl; // ここで例外
    }
    catch (const runtime_error &e)
    {
        cout << "エラー: " << e.what() << endl;;
    }
}

• ポイント: throw (投げる)で知らせ、try/catch (試みる/受け取る)で受けて落ちずに処理を制御する。

対応していないと…

• 無視して計算続行 → 誤結果。
• 途中で落ちる/ハング → クラッシュ、セーブデータ破損など。
• 現場では「再現困難」「原因不明」になりがち。必ず観測可能に（ログ・メッセージ）。

1. try/throw/catch の基本とcatch順序
2. 伝播と再スロー（どの層で決着させるか）
3. RAII (ライ)による自動後始末（例外時も安全） RAIIは変数やオブジェクトの確保、初期化、破棄の紐づけ。しっかりやろう！
4. 独自例外と標準系の使い分け
5. VSデバッガでスローの瞬間を観察

エンジニアとしてのやることチェック

• 事前条件チェック＋fail fast。握りつぶさない。
• 具体→抽象の順でcatchを並べる。
• リソースはRAII（vector/unique_ptr/fstream/lock_guard）。
• 例外時のログとユーザーへの扱い（代替/中断/再試行）を設計。
• 「例外にすべきか戻り値で良いか」の境界を決めて統一。

この資料で学ぶこと

• try / throw / catch の基本を身につける。
• 複数の型で catch する順序とコツを理解する。
• 例外の伝播 と 再スロー（throw;） を体験する。
• std::exception 系と独自例外クラスの使い分けを知る。
• RAII と例外安全（new/delete より vector やスマートポインタ）を実感する。
• Visual Studio で「例外がスローされる瞬間」をデバッグ実行で観察する。

1. 基本構文（23_try_basic.cpp）

// 23_try_basic.cpp
#include <iostream>
#include <stdexcept>
using namespace std;

int divide(int a, int b)
{
    if (b == 0)
    {
        throw runtime_error("0で割ることはできません");
    }
    return a / b;
}

int main(void)
{
    try
    {
        cout << divide(10, 2) << endl;;
        cout << divide(5, 0) << endl;; // ここで例外
        cout << "ここには到達しません\n";
    }
    catch (const runtime_error &e)
    {
        cout << "実行時エラー: " << e.what() << endl;
    }
    catch (...)
    {
        cout << "想定外の例外を捕捉" << endl;;
    }
    return 0;
}

ポイント

• throw で例外オブジェクトを投げる。
• catch (型) はより具体的な型から並べる（順序が大事）。
• 最後の catch (...) はどんな型でも受け止める保険。

2. 複数catchと順序（23_catch_order.cpp）

// 23_catch_order.cpp
#include <iostream>
#include <stdexcept>
using namespace std;

void f(int code)
{
    if (code == 1)
    {
        throw out_of_range("範囲外");
    }
    else if (code == 2)
    {
        throw runtime_error("実行時");
    }
    else
    {
        throw exception();
    }
}

int main(void)
{
    try
    {
        f(1); // 1,2,その他 を変えて試す
    }
    catch (const out_of_range &e)
    {
        cout << "out_of_range: " << e.what()  << endl;
    }
    catch (const runtime_error &e)
    {
        cout << "runtime_error: " << e.what() << endl;
    }
    catch (const exception &e)
    {
        cout << "exception: " << e.what() << endl;
    }
}

ポイント

• 基底クラス std::exception は最後に。
• 具体→抽象の順に並べないと、上位型で先に捕まり下位に到達しません。

3. 例外の伝播と再スロー（23_rethrow.cpp）

// 23_rethrow.cpp
#include <iostream>
#include <stdexcept>
using namespace std;

void low()
{
    throw runtime_error("lowで失敗");
}

void mid()
{
    try
    {
        low();
    }
    catch (const runtime_error &)
    {
        // ログだけ取り、呼び出し元へそのまま再スロー
        throw;
    }
}

int main(void)
{
    try
    {
        mid();
    }
    catch (const exception &e)
    {
        cout << "mainで捕捉: " << e.what() << endl;
    }
}

ポイント

• いったん受けて throw;（オブジェクトを書かない）で元の例外を再スロー。
• ロギングやリソース解放をはさみつつ、責任のある層で処理を完了させる設計に。

4. RAIIと例外安全（23_raii_safety.cpp）

// 23_raii_safety.cpp
#include <iostream>
#include <vector>
#include <memory>
using namespace std;

class Enemy
{
public:
    explicit Enemy(int hp) : hp_(hp) {}
    int hp() const { return hp_; }
private:
    int hp_;
};

int main(void)
{
    // 例外が起きても自動で後始末される安全な資源管理
    vector<unique_ptr<Enemy>> es;
    es.push_back(make_unique<Enemy>(10));
    es.push_back(make_unique<Enemy>(20));

    // 途中で例外が起きてもOK（ここでは例として投げる）
    throw runtime_error("途中で失敗");

    // 到達しないが、esはスコープ終了時に自動解放される
}

ポイント

• new/delete は例外時にdelete漏れが起きやすい。
• RAII（スコープ終了で自動解放）な vector や unique_ptr を使うのが基本方針。

5. 独自例外クラス（23_custom_exception.cpp）

// 23_custom_exception.cpp
#include <iostream>
#include <stdexcept>
#include <string>
using namespace std;

class InvalidHpError : public runtime_error
{
public:
    explicit InvalidHpError(const string &msg) : runtime_error(msg) {}
};

class Enemy
{
public:
    explicit Enemy(int hp)
    {
        if (hp < 0)
        {
            throw InvalidHpError("HPが負です: " + to_string(hp));
        }
        hp_ = hp;
    }
private:
    int hp_ = 0;
};

int main(void)
{
    try
    {
        Enemy e(-5);
    }
    catch (const InvalidHpError &e)
    {
        cout << "InvalidHpError: " << e.what() << endl;
    }
}

ポイント

• 標準の系統（std::logic_error / std::runtime_error など）を継承して意味を明確に。
• what() に詳細を入れて原因調査を早くする。

6. Visual Studioで「例外の瞬間」を見る

1. 本章いずれかのソースをデバッグ実行（F5）。
2. 例外がスローされる行にブレーク（自動で止まる or 自分でブレークポイントを設定）。
3. 呼び出し履歴（Call Stack） で伝播の経路を確認。
4. ローカル／自動 ウィンドウで変数の値を観察。
5. catch の中にブレークポイントを置き、捕捉→継続の流れを確認。

体験タスク：23_rethrow.cpp を使い、low → mid → main の順に例外が通過する様子を一歩ずつ観察する。

7. よくある落とし穴チェックリスト

• catch の順序：具体 → 抽象。
• new 後に例外 → delete 漏れ。→ vector とスマートポインタに置き換える。
• 例外を握りつぶす catch (...) {} の乱用。
• 例外安全でない部分的更新（途中例外で不整合）。→ トランザクション的に設計する。
• 不要な throw の多用。→ 事前条件チェックで分岐処理できるならそれを優先。

理解度チェック（四肢択一・IPA風）

問1（23_q1.cpp） catch の並びとして正しいものを選べ。

ア catch(const exception&) → catch(const out_of_range&) → catch(...)

イ catch(const out_of_range&) → catch(const exception&) → catch(...)

ウ catch(...) → catch(const runtime_error&) → catch(const exception&)

エ catch(const exception&) → catch(const runtime_error&) → catch(const out_of_range&)

問2（23_q2.cpp） 再スロー（throw;）について正しい説明を選べ。

ア throw e; と throw; は常に同じ挙動である。

イ throw; は直近で捕捉した例外をそのまま再スローする。

ウ throw; は新しい exception() を投げ直す。

エ throw; は try の外でも使える。

問3（23_q3.cpp） 例外安全の観点で望ましい選択を選べ。

ア new で配列確保し、例外時は手作業で delete[]。

イ vector<Enemy*> に new で格納し、終了時に delete をループで実行。

ウ vector<Enemy> もしくは vector<unique_ptr<Enemy>> を使う。

エ 例外は使わず exit(1) で終了する。

問4（23_q4.cpp） 次の divide はどのように改善すべきか。

int divide(int a, int b)
{
    if (b == 0)
    {
        // TODO: 改善
    }
    return a / b;
}

ア return 0; にしておけば安全。

イ throw runtime_error("0で割れない"); として呼び出し側で catch。

ウ cout << "エラー"; を出して続行。

エ assert(b != 0); のみ。

演習（提出課題）

演習1（23_ex1_guarded_load.cpp）

目的: リソース読み込み失敗を例外で扱い、安全に後始末する。

• loadTexture(const string&) を作成。拡張子が .png 以外なら invalid_argument を throw。
• main では vector<unique_ptr<int>> など簡易なリソースを確保後、わざと loadTexture("enemy.dat") を呼び例外を発生させる。
• catch でメッセージ表示。終了時に確保済み資源が自動解放されることを確認。

演習2（23_ex2_custom_error.cpp）

目的: 独自例外で入力不正を表現。

• class InvalidParam : public runtime_error を作る。
• Enemy のコンストラクタで hp < 0 または name.empty() なら InvalidParam を投げる。
• try 範囲で複数回生成を試し、catch(const InvalidParam&) で個別メッセージを表示。

演習3（23_ex3_rethrow_chain.cpp）

目的: 伝播と再スローのパターンを体験。

• low() → mid() → main() の三層構造。
• low() で runtime_error を投げ、mid() でログだけ出して throw;。
• main() で最終捕捉し、ユーザー向けメッセージを表示。

提出物：ソース一式と実行ログ。どこで何を捕捉し、どのように再スローしたかをコメントで説明すること。

まとめ

• 例外は異常系を分離し、上位に伝播して責任ある場所で処理できる。
• catch は具体 → 抽象。catch(...) は最後の保険。
• RAII とスマートポインタで例外時も自動解放。new/delete を直接使わない設計を基本に。
• 独自例外で意味を明確にし、what() を有益にする。
• Visual Studio のデバッガでスローの瞬間を観察して理解を定着させる。