try-catch 구문

try {
    // 예외가 발생할 가능성이 있는 코드
    // ...
    // 만약 예외 상황 발생 시:
    // throw 예외_객체;
} catch (예외_타입1 매개변수_이름1) {
    // 예외_타입1에 해당하는 예외가 발생했을 때 실행될 코드
    // ...
} catch (예외_타입2 매개변수_이름2) {
    // 예외_타입2에 해당하는 예외가 발생했을 때 실행될 코드
    // ...
} catch (...) { // 모든 타입의 예외를 잡는 catch 블록 (선택 사항)
    // 위에서 명시된 어떤 예외 타입에도 해당하지 않는 예외가 발생했을 때 실행될 코드
    // ...
}

#include <iostream>
#include <string>
#include <exception>

int main() {
    try {
        throw 7;
    } catch (double) {
        std::cout << "double\n";
    } catch (int code) {
        std::cout << "int " << code << '\n';
    }

    try {
        throw std::string("retry");
    } catch (const std::exception&) {
        std::cout << "standard exception\n";
    } catch (const std::string& message) {
        std::cout << "string " << message << '\n';
    }
}

#include <iostream>
#include <string> // 예외로 문자열을 던질 수 있습니다.

double divide(int numerator, int denominator) {
    if (denominator == 0) {
        // 0으로 나누는 상황은 비정상적이므로 예외를 던집니다.
        // 여기서는 C-스타일 문자열을 예외로 던져보겠습니다.
        throw "Error: Division by zero is not allowed!";
    }
    return static_cast<double>(numerator) / denominator;
}

int main() {
    std::cout << "--- 예외 발생 상황 ---" << std::endl;
    try {
        double result = divide(10, 0); // 0으로 나누는 함수 호출
        std::cout << "Result: " << result << std::endl; // 이 줄은 실행되지 않습니다.
    } catch (const char* errorMessage) { // C-스타일 문자열 예외를 잡습니다.
        std::cerr << "Caught exception: " << errorMessage << std::endl;
    }
    std::cout << "Program continues after exception handling." << std::endl;
    std::cout << std::endl;

    std::cout << "--- 정상 실행 상황 ---" << std::endl;
    try {
        double result = divide(10, 2); // 정상적인 나누기 함수 호출
        std::cout << "Result: " << result << std::endl; // 이 줄은 정상적으로 실행됩니다.
    } catch (const char* errorMessage) {
        // 이 catch 블록은 실행되지 않습니다.
        std::cerr << "Caught exception: " << errorMessage << std::endl;
    }
    std::cout << "Program continues normally." << std::endl;

    return 0;
}

--- 예외 발생 상황 ---
Caught exception: Error: Division by zero is not allowed!
Program continues after exception handling.

--- 정상 실행 상황 ---
Result: 5
Program continues normally.

#include <iostream>
#include <string>
#include <stdexcept> // 표준 예외 클래스들을 사용하기 위해 포함

// 이 예시에서 지원하지 않는 연산자를 보고할 예외 클래스 (사용자 정의 예외)
class OutOfRangeException : public std::runtime_error {
public:
    // 생성자에서 부모 클래스의 생성자를 호출하여 메시지를 전달합니다.
    OutOfRangeException(const std::string& msg) : std::runtime_error(msg) {}
};

double calculate(int val1, int val2, char op) {
    if (op == '/') {
        if (val2 == 0) {
            // 0으로 나누는 경우, 표준 예외 std::invalid_argument를 던집니다.
            throw std::invalid_argument("Division by zero error!");
        }
    } else if (op != '+' && op != '-' && op != '*' && op != '/') {
        // 유효하지 않은 연산자일 경우, 사용자 정의 예외를 던집니다.
        throw OutOfRangeException("Invalid operator provided.");
    }

    // 간단한 계산 로직 (예외 발생 조건에만 집중)
    if (op == '+') return static_cast<double>(val1) + val2;
    if (op == '-') return static_cast<double>(val1) - val2;
    if (op == '*') return static_cast<double>(val1) * val2;
    if (op == '/') return static_cast<double>(val1) / val2;

    return 0.0; // 도달하지 않는 코드
}

int main() {
    // 0으로 나누기 예외 상황
    std::cout << "--- Case 1: Division by Zero ---" << std::endl;
    try {
        double result = calculate(10, 0, '/');
        std::cout << "Result: " << result << std::endl;
    } catch (const std::invalid_argument& e) { // std::invalid_argument 예외를 잡습니다.
        std::cerr << "Error (Invalid Argument): " << e.what() << std::endl;
    } catch (const OutOfRangeException& e) {
        std::cerr << "Error (Out of Range): " << e.what() << std::endl;
    } catch (const std::exception& e) { // 모든 표준 예외의 부모 클래스를 잡습니다.
        std::cerr << "Error (General Std Exception): " << e.what() << std::endl;
    } catch (...) { // 그 외 모든 예외를 잡습니다.
        std::cerr << "Error (Unknown Exception)!" << std::endl;
    }
    std::cout << "--- End of Case 1 ---" << std::endl << std::endl;

    // 유효하지 않은 연산자 예외 상황
    std::cout << "--- Case 2: Invalid Operator ---" << std::endl;
    try {
        double result = calculate(5, 2, '%'); // 유효하지 않은 연산자
        std::cout << "Result: " << result << std::endl;
    } catch (const std::invalid_argument& e) {
        std::cerr << "Error (Invalid Argument): " << e.what() << std::endl;
    } catch (const OutOfRangeException& e) { // OutOfRangeException 예외를 잡습니다.
        std::cerr << "Error (Out of Range): " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error (General Std Exception): " << e.what() << std::endl;
    } catch (...) {
        std::cerr << "Error (Unknown Exception)!" << std::endl;
    }
    std::cout << "--- End of Case 2 ---" << std::endl << std::endl;

    // 정상 실행 상황
    std::cout << "--- Case 3: Normal Calculation ---" << std::endl;
    try {
        double result = calculate(20, 5, '*');
        std::cout << "Result: " << result << std::endl;
    } catch (const std::invalid_argument& e) {
        std::cerr << "Error (Invalid Argument): " << e.what() << std::endl;
    } catch (const OutOfRangeException& e) {
        std::cerr << "Error (Out of Range): " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error (General Std Exception): " << e.what() << std::endl;
    } catch (...) {
        std::cerr << "Error (Unknown Exception)!" << std::endl;
    }
    std::cout << "--- End of Case 3 ---" << std::endl << std::endl;

    return 0;
}

--- Case 1: Division by Zero ---
Error (Invalid Argument): Division by zero error!
--- End of Case 1 ---

--- Case 2: Invalid Operator ---
Error (Out of Range): Invalid operator provided.
--- End of Case 2 ---

--- Case 3: Normal Calculation ---
Result: 100
--- End of Case 3 ---