[C++] 例外処理の基本と使いどころ

#include <iostream>
#include <stdexcept>
int parseInteger(const std::string& input) {
    try {
        size_t pos;
        int value = std::stoi(input, &pos);
        if (pos < input.size()) {
            throw std::invalid_argument("入力が整数ではありません");
        }
        return value;
    } catch (const std::invalid_argument& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
        throw; // 例外を再スロー
    }
}
int main() {
    try {
        int number = parseInteger("123abc");
        std::cout << "入力された整数: " << number << std::endl;
    } catch (...) {
        std::cerr << "入力データの検証に失敗しました" << std::endl;
    }
    return 0;
}

エラー: 入力が整数ではありません
入力データの検証に失敗しました

#include <iostream>
#include <fstream>
#include <stdexcept>
void readFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        throw std::runtime_error("ファイルを開くことができません");
    }
    std::string line;
    while (std::getline(file, line)) {
        std::cout << line << std::endl;
    }
}
int main() {
    try {
        readFile("nonexistent.txt");
    } catch (const std::runtime_error& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }
    return 0;
}

エラー: ファイルを開くことができません

#include <iostream>
#include <stdexcept>
void allocateMemory(size_t size) {
    try {
        int* array = new int[size];
        // メモリ確保に成功した場合の処理
        delete[] array;
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリ確保に失敗しました: " << e.what() << std::endl;
        throw; // 例外を再スロー
    }
}
int main() {
    try {
        allocateMemory(1000000000000); // 大きすぎるサイズを指定
    } catch (...) {
        std::cerr << "メモリ管理における例外処理に失敗しました" << std::endl;
    }
    return 0;
}

メモリ確保に失敗しました: std::bad_alloc
メモリ管理における例外処理に失敗しました

#include <iostream>
#include <stdexcept>
// 仮想的なネットワーク通信関数
void connectToServer(const std::string& server) {
    // 通信エラーをシミュレート
    throw std::runtime_error("サーバーへの接続に失敗しました");
}
int main() {
    try {
        connectToServer("example.com");
    } catch (const std::runtime_error& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }
    return 0;
}

エラー: サーバーへの接続に失敗しました

#include <iostream>
#include <stdexcept>
void process() {
    try {
        throw std::runtime_error("処理中にエラーが発生しました");
    } catch (const std::runtime_error& e) {
        std::cerr << "process内で捕捉: " << e.what() << std::endl;
        throw; // 例外を再スロー
    }
}
int main() {
    try {
        process();
    } catch (const std::runtime_error& e) {
        std::cerr << "main内で捕捉: " << e.what() << std::endl;
    }
    return 0;
}

process内で捕捉: 処理中にエラーが発生しました
main内で捕捉: 処理中にエラーが発生しました

#include <iostream>
#include <stdexcept>
void readData() {
    throw std::runtime_error("データ読み込みエラー");
}
void processData() {
    try {
        readData();
    } catch (const std::runtime_error& e) {
        std::cerr << "データ処理中にエラー: " << e.what() << std::endl;
        // 必要に応じて再スロー
    }
}
int main() {
    try {
        processData();
    } catch (const std::runtime_error& e) {
        std::cerr << "main内で捕捉: " << e.what() << std::endl;
    }
    return 0;
}

データ処理中にエラー: データ読み込みエラー

#include <iostream>
#include <vector>
#include <stdexcept>
class Resource {
public:
    Resource() { std::cout << "リソース確保" << std::endl; }
    ~Resource() { std::cout << "リソース解放" << std::endl; }
};
void useResource() {
    Resource res;
    throw std::runtime_error("リソース使用中にエラー");
}
int main() {
    try {
        useResource();
    } catch (const std::runtime_error& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }
    return 0;
}

リソース確保
リソース解放
エラー: リソース使用中にエラー

#include <iostream>
#include <memory>
#include <stdexcept>
void useSmartPointer() {
    std::unique_ptr<int> ptr(new int(42)); // スマートポインタでメモリを管理
    std::cout << "値: " << *ptr << std::endl;
    throw std::runtime_error("例外発生");
    // 例外が発生しても、ptrは自動的に解放される
}
int main() {
    try {
        useSmartPointer();
    } catch (const std::runtime_error& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }
    return 0;
}

値: 42
エラー: 例外発生

#include <iostream>
#include <stdexcept>
class FileHandler {
public:
    FileHandler(const std::string& filename) {
        std::cout << "ファイルを開く: " << filename << std::endl;
        // ファイルを開く処理(仮想)
    }
    ~FileHandler() {
        std::cout << "ファイルを閉じる" << std::endl;
        // ファイルを閉じる処理(仮想)
    }
};
void processFile() {
    FileHandler file("example.txt");
    throw std::runtime_error("ファイル処理中にエラー");
    // 例外が発生しても、fileは自動的に閉じられる
}
int main() {
    try {
        processFile();
    } catch (const std::runtime_error& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }
    return 0;
}

ファイルを開く: example.txt
ファイルを閉じる
エラー: ファイル処理中にエラー

#include <iostream>
#include <thread>
#include <stdexcept>
void threadFunction() {
    try {
        throw std::runtime_error("スレッド内で例外発生");
    } catch (const std::runtime_error& e) {
        std::cerr << "スレッド内で捕捉: " << e.what() << std::endl;
    }
}
int main() {
    std::thread t(threadFunction);
    t.join();
    std::cout << "メインスレッド終了" << std::endl;
    return 0;
}

スレッド内で捕捉: スレッド内で例外発生
メインスレッド終了