예외 처리의 기본 개념

프로그램 실행 중 발생할 수 있는 예상치 못한 문제, 즉 오류(Error)나 예외(Exception)를 처리하는 기준을 다룹니다.

이 절에서는 C++의 예외 처리(Exception Handling) 메커니즘을 다룹니다. 함수 호출과 반환, 지역 객체의 수명, 앞 장의 클래스 상속을 바탕으로 읽습니다. 각 main이 있는 코드는 별도 파일로 실행하고, throw·try·catch만 보이는 짧은 형식은 해당 함수나 타입을 준비한 뒤 넣는 발췌입니다.

예외 처리는 프로그램의 안정성을 높이고, 오류 발생 시 적절하게 대응하여 프로그램이 비정상적으로 종료되는 것을 방지하는 데 필수적인 기법입니다.

예외(Exception)란 무엇인가?

프로그램이 실행되는 동안 발생할 수 있는 비정상적인 상황을 예외(Exception)라고 합니다.

이는 일반적으로 프로그램이 정상적인 흐름을 이어갈 수 없음을 의미합니다.

• 메모리 부족: new 연산자가 메모리 할당에 실패한 경우 (std::bad_alloc)
• 파일 열기 실패: 존재하지 않는 파일을 열려고 시도하거나, 권한이 없어 열 수 없는 경우
• 배열/컨테이너 범위 초과: std::vector::at()처럼 검사하는 API는 std::out_of_range를 던집니다. 일반 배열이나 operator[] 범위 초과가 자동으로 C++ 예외가 되지는 않습니다.
• 0으로 나누기: 0 여부를 직접 검사해 throw할 수 있습니다. 정수의 0 나눗셈 자체는 정의되지 않은 동작이며 catch로 복구하는 C++ 예외가 아닙니다.
• 네트워크 연결 끊김: 데이터를 전송하는 도중 네트워크 연결이 끊어진 경우

이러한 예외 상황이 발생했을 때 적절히 처리하지 않으면 프로그램은 비정상적으로 종료되거나, 예측 불가능한 결과를 초래할 수 있습니다. 다만 운영상의 실패가 모두 자동으로 C++ 예외가 되는 것은 아닙니다. 기본 파일 스트림은 열기·쓰기 실패를 상태 플래그로 알리고, 예외 마스크나 직접 검사해 throw하는 정책을 따로 정할 수 있습니다. 네트워크 API도 반환값과 예외 중 어떤 계약인지 확인해야 합니다.

기존 오류 처리 방식의 한계

예외 처리 메커니즘이 도입되기 전이나, 간단한 오류 처리 시에는 주로 다음과 같은 방식을 사용했습니다.

#include <iostream>
int divide(int a, int b) {
    if (b == 0) {
        std::cerr << "Error: Division by zero!\n";
        return -1; // 오류를 나타내는 특수 값 반환
    }
    return a / b;
}

int main() {
    int result = divide(10, 0);
    if (result == -1) {
        // 오류 처리
    } else {
        // 정상 처리
    }
    return 0;
}

반환값 방식도 실패를 명확히 구분하고 호출자가 확인하는 계약이라면 유효합니다. 위 divide의 문제는 -1을 실패 표식으로 쓰면서 정상 결과 -1도 허용한다는 점입니다. assert는 개발 중의 전제 위반을 찾는 도구이며, 사용자가 낸 잘못된 입력을 catch로 복구하는 장치가 아닙니다.

예시 원 divide에 -2와 2를 주면 정수 나눗셈의 정상 결과도 -1입니다. 분모가 0인 호출은 오류 메시지를 내고 -1을 반환하지만, result만 보는 호출자는 두 경우를 구별할 수 없습니다. 아래 safeDivide는 분모가 0일 때만 std::string 예외를 던져 정상 값과 실패 경로를 나눕니다. 이 예에서는 유한한 작은 입력을 사용하며, 모든 수치 검증을 완성한 함수라고 해석하지 않습니다.

스스로 확인하기 원 반환값 divide에 (-6, 3)과 (-2, 2)를 넣었을 때 result == -1 검사는 각각 어떤 경로를 고를까요? 분모가 0인 경우와 정상적인 음수 결과를 이 반환값 하나로 항상 구별할 수 있는지도 설명하세요.

예외 처리의 기본 메커니즘

C++의 예외 처리 메커니즘은 다음과 같은 세 가지 키워드를 중심으로 이루어집니다.

throw "Error: Division by zero!"; // C-스타일 문자열 예외
throw 404;                     // int 타입 예외
throw MyException("Invalid input"); // 사용자 정의 예외 객체

try {
    // 예외가 발생할 수 있는 코드
    // ...
}

try {
    // 예외 발생 가능 코드
} catch (int ex_code) { // int 타입 예외를 잡음
    std::cerr << "Caught integer exception: " << ex_code << std::endl;
    // 예외 처리 로직
} catch (const char* msg) { // C-스타일 문자열 예외를 잡음
    std::cerr << "Caught string exception: " << msg << std::endl;
    // 예외 처리 로직
} catch (...) { // 모든 종류의 예외를 잡음 (catch-all)
    std::cerr << "Caught unknown exception!" << std::endl;
    // 예외 처리 로직
}

#include <iostream>
#include <string>

double safeDivide(double numerator, double denominator) {
    if (denominator == 0) {
        throw std::string("Error: Division by zero is not allowed!"); // std::string 객체 던지기
    }
    return numerator / denominator;
}

int main() {
    double num1 = 10.0;
    double num2 = 2.0;
    double num3 = 0.0;

    // 1. 정상적인 경우
    try {
        double result = safeDivide(num1, num2);
        std::cout << "Result of " << num1 << " / " << num2 << " = " << result << std::endl;
    } catch (const std::string& e) { // std::string 예외를 잡음
        std::cerr << "Caught exception: " << e << std::endl;
    }

    std::cout << "-------------------------------------------\n";

    // 2. 예외가 발생하는 경우
    try {
        double result = safeDivide(num1, num3); // 여기서 예외가 발생
        std::cout << "This line will not be executed." << std::endl; // 실행되지 않음
    } catch (const std::string& e) { // 던져진 std::string 예외를 잡음
        std::cerr << "Caught exception: " << e << std::endl; // 출력: Caught exception: Error: Division by zero is not allowed!
    } catch (int errorCode) { // int 예외는 잡지 않음
        std::cerr << "Caught integer error code: " << errorCode << std::endl;
    } catch (...) { // 다른 모든 예외를 잡음
        std::cerr << "Caught an unexpected exception type." << std::endl;
    }

    std::cout << "Program continues after exception handling.\n";
    return 0;
}

예외의 전파 (Exception Propagation)

예외 처리의 기본 개념은 실패 타입, 복구 범위, 자원 정리 책임을 기준으로 확인합니다.

throw 문이 실행되면, C++ 런타임 시스템은 가장 가까운 활성 try에서 호환 handler를 찾습니다. 같은 함수에 해당 catch가 있으면 먼저 그 범위에서 처리할 수 있으며, 바로 호출자에게 돌아가는 정상 return과는 다릅니다.

만약 그 호출한 곳에 해당 예외를 처리할 catch 블록이 없다면, 다시 그 함수를 호출한 곳으로 제어를 옮기는 과정을 반복합니다.

이 과정을 스택 풀기(Stack Unwinding) 또는 예외 전파(Exception Propagation)라고 합니다.

호출 스택을 역추적하면서 catch 블록을 찾다가, 최종적으로 main 함수까지 도달했는데도 적절한 catch 블록을 찾지 못하면 프로그램은 비정상적으로 종료됩니다 (std::terminate 호출).

#include <iostream>
#include <string>

void functionC() {
    std::cout << "Inside functionC\n";
    throw "An error occurred in functionC!"; // C-스타일 문자열 예외를 던짐
    std::cout << "This line in functionC will not be executed.\n";
}

void functionB() {
    std::cout << "Inside functionB\n";
    // functionB에는 catch 블록이 없으므로, 예외는 functionA로 전파됨
    functionC();
    std::cout << "This line in functionB will not be executed.\n";
}

void functionA() {
    std::cout << "Inside functionA\n";
    try {
        functionB(); // functionB에서 예외가 발생하여 여기로 전파됨
        std::cout << "This line in functionA's try block will not be executed.\n";
    } catch (const char* message) { // functionA에서 C-스타일 문자열 예외를 잡음
        std::cerr << "Caught exception in functionA: " << message << std::endl;
    }
    std::cout << "Exiting functionA.\n";
}

int main() {
    std::cout << "Starting main...\n";
    functionA();
    std::cout << "Main finished.\n";
    return 0;
}

Starting main...
Inside functionA
Inside functionB
Inside functionC
Caught exception in functionA: An error occurred in functionC!
Exiting functionA.
Main finished.

functionC에서 예외가 던져진 후, functionB는 예외를 처리하지 않고 바로 functionA로 예외를 전파합니다.

functionA의 try-catch 블록에서 해당 예외를 잡고 처리하는 것을 볼 수 있습니다. 원 출력에는 cout과 cerr가 함께 있으므로 별도 출력 창에서 수집하면 표시 순서가 다를 수 있습니다. 코드가 호출한 순서와 서로 다른 스트림을 나중에 합쳐 표시한 순서를 구분하세요.

위 예제에서는 functionC와 functionB를 벗어나 functionA의 catch로 이동합니다. 이때 벗어나는 범위의 완전히 생성된 자동 객체는 생성의 역순으로 정리됩니다. functionA 전체가 끝나는 것은 아니므로, catch가 정상적으로 끝난 뒤 Exiting functionA. 출력도 실행됩니다.

이 과정을 스택 풀기(Stack Unwinding)라고 합니다.

다음은 예외 전파에 RAII 자원 정리를 더한 일반적인 흐름입니다. 위 functionA/B/C 예제에는 Guard 객체가 없으며, 그림의 service/parse는 역할을 나타내는 별도 예시입니다.

예외 처리는 오류를 숨기는 장치가 아니라, 실패를 복구할 수 있는 호출 경계까지 전달하고 스택을 풀며 자원을 정리하는 구조입니다.

전파 범위를 독립 판단하기 원 functionC가 throw하기 전에 같은 함수 안의 try-catch로 그 예외를 잡고 catch 뒤에서 정상 종료하도록 바뀌었다고 합시다. functionB의 호출 다음 출력과 functionA의 try 안의 호출 다음 출력은 실행될까요? 반대로 functionA에서 예외를 잡은 뒤 functionB의 중단된 지점으로 돌아가지는 않는 이유도 설명하세요.

처리할 handler를 찾지 못하거나 noexcept 경계를 넘으면 std::terminate가 호출될 수 있습니다. 그런 종료 경로에서 모든 지역 객체의 정리가 보장된다고 가정하지 않습니다.