핵심 요약

**C++ RAII(Resource Acquisition Is Initialization, 또는 SBRM: Scope-Bound Resource Management)**는 사용 전에 반드시 획득해야 하는 자원(할당된 힙 메모리, 실행 스레드, 열린 소켓, 열린 파일, 잠근 뮤텍스 등)의 생명주기를 객체의 수명에 묶는 기법(cppreference RAII)입니다. 생성자에서 자원을 획득(실패 시 예외 발생)하고 소멸자에서 예외 없이 해제하므로, 정상적인 스코프 종료든 조기 반환(early return)이든 예외로 인한 스택 되감기(stack unwinding)든 제어 객체의 수명이 끝날 때 **획득의 역순(in reverse order of acquisition)**으로 자원이 누수 없이 자동 해제됩니다.

C++ RAII란? 자원 수명을 객체 수명에 묶는다는 뜻은?

한 줄 답: C++ RAII는 사용 전에 획득해야 하는 자원의 생명주기를 자동 저장 기간(또는 임시 수명) 객체의 생성자와 소멸자에 결합하여, 스코프를 벗어날 때 획득의 역순으로 자동 해제되도록 보장하는 기법입니다.

  • 정의와 별칭: cppreference에 따르면 C++ RAII는 사용 전에 획득해야 하는 자원(할당된 힙 메모리, 실행 스레드, 열린 소켓, 열린 파일, 잠근 뮤텍스 등)의 생명주기를 객체의 수명에 결합합니다. 스코프에 묶여 자원을 관리한다는 의미에서 **SBRM(Scope-Bound Resource Management)**이라고도 부릅니다.
  • 핵심 동작 규칙:
    • 생성자(Constructor): 자원을 획득하며, 획득에 실패하면 예외를 던집니다. 만약 생성 도중 예외가 발생하면 이미 완전히 생성된 멤버와 기반 클래스들은 초기화의 역순으로 해제됩니다.
    • 소멸자(Destructor): 자원을 해제하며, 절대 예외를 던지지 않습니다(never throws).
    • 사용 방식(Storage duration): 자동 저장 기간(automatic storage duration, 스택 지역 변수) 또는 임시 객체 수명(temporary lifetime)을 가진 객체를 통해 사용합니다. 이는 객체 수명, 스코프 종료(scope exit), 초기화 순서, 스택 되감기(stack unwinding)라는 C++ 언어 규칙을 그대로 활용합니다.
    • 해제 순서: 제어 객체의 수명이 끝날 때 모든 자원을 **획득의 역순(in reverse order of acquisition)**으로 해제합니다.
  • 적용 제외 대상: CPU 시간, 네트워크 대역폭, 스택 메모리처럼 사용 전에 먼저 획득 과정을 거치지 않는 자원에는 RAII가 적용되지 않습니다.
  • 단일 인자 RAII 생성자에서 의도치 않은 암시적 변환을 막는 explicit 설계는 C++ explicit 정리 글을 참고하시기 바랍니다.

RAII 스코프와 소멸자 해제 흐름

실제 실행 결과 (g++ (Debian 14.2.0-19) 14.2.0, g++ -std=c++17 -Wall -o raii raii.cpp && ./raii)

#include <cstdio>
#include <mutex>
#include <stdexcept>

struct Guard {
    const char* name;
    explicit Guard(const char* n) : name(n) { std::printf("acquire %s\n", name); }
    ~Guard() { std::printf("release %s\n", name); }
    Guard(const Guard&) = delete;
    Guard& operator=(const Guard&) = delete;
};

void work(bool fail) {
    Guard a("A");
    Guard b("B");
    if (fail) throw std::runtime_error("boom");
    std::printf("work done\n");
}

int main() {
    work(false);
    try { work(true); } catch (const std::exception& e) { std::printf("caught: %s\n", e.what()); }
    std::mutex m;
    { std::lock_guard<std::mutex> lk(m); std::printf("inside lock_guard scope\n"); }
    std::printf("after scope try_lock: %s\n", m.try_lock() ? "ok" : "fail");
    m.unlock();
}
acquire A
acquire B
work done
release B
release A
acquire A
acquire B
release B
release A
caught: boom
inside lock_guard scope
after scope try_lock: ok

위 실행 결과에서 볼 수 있듯, 정상 반환(work(false))과 예외 발생(work(true)) 모두에서 A → B 순서로 자원을 획득한 뒤 B → A 역순으로 소멸자가 호출됩니다. 특히 예외가 발생했을 때는 catch 블록이 실행되기 전에 스택 되감기(stack unwinding)가 먼저 일어나 자원이 해제됩니다. 이어지는 std::lock_guard 블록에서도 스코프가 끝나자마자 뮤텍스가 자동 해제되어, 블록 직후 m.try_lock()이 ok를 출력합니다.

RAII 없이 쓰면 어떤 버그가 생기나요?

한 줄 답: 자원 획득과 해제를 별도 함수 호출에 맡기면 조기 반환(early return)이나 예외 발생 시 해제 코드가 건너뛰어져 뮤텍스 영구 잠금이나 메모리·파일 누수가 발생합니다.

  • 비-RAII(non-RAII) 패턴: open()/close(), lock()/unlock(), init()/destroy()를 따로 호출하게 만든 클래스나 수동 delete, fclose, unlock 호출에 의존하는 코드는 전형적인 비-RAII 사례입니다.
  • bad() vs good() 뮤텍스 문제: cppreference의 뮤텍스 예시처럼, 수동으로 m.lock()을 호출한 뒤 작업 도중 조건문으로 조기 반환(early return)하거나 내부에서 호출한 함수 f()가 예외를 던지면 아래쪽의 m.unlock()에 도달하지 못합니다. 그 결과 뮤텍스가 잠긴 채 남게 되지만, std::lock_guard를 쓰는 good() 방식은 어떤 경로로 함수를 빠져나가든 소멸자가 뮤텍스를 안전하게 해제합니다.

수동 lock/unlock과 lock_guard 비교

표준 라이브러리 RAII는 언제 쓰나요?

한 줄 답: 힙 버퍼, 동적 할당 객체, 뮤텍스 잠금, 파일 스트림을 다룰 때는 직접 해제 함수를 호출하는 대신 표준 라이브러리가 제공하는 RAII 컨테이너와 래퍼를 사용합니다.

  • 자체 자원을 관리하는 컨테이너: std::string과 std::vector는 내부 힙 메모리를 객체 수명에 맞춰 스스로 할당하고 소멸자에서 해제합니다.
  • 스마트 포인터(동적 메모리 래퍼): std::unique_ptr와 std::shared_ptr(각각 std::make_unique, std::make_shared로 생성)는 수동 delete 없이 동적 할당된 객체의 수명을 관리합니다.
  • 뮤텍스 잠금 래퍼: 단일 뮤텍스를 스코프 동안 잠그는 std::lock_guard, 유연한 잠금 제어를 지원하는 std::unique_lock, 공유 잠금용 std::shared_lock, 그리고 여러 뮤텍스를 데드락 없이 동시에 잠그는 C++17 std::scoped_lock이 있습니다.
  • 파일 입출력: std::fstream은 객체가 소멸될 때 소멸자에서 열린 파일을 자동으로 닫습니다.
  • 직접 RAII 클래스를 설계할 때: 위 코드의 Guard 구조체처럼 커스텀 RAII 래퍼를 만들 때는 두 객체가 같은 자원을 중복 해제하지 않도록 복사 생성자와 복사 대입 연산자를 삭제(= delete)하고, 필요한 경우에만 이동을 허용합니다(자세한 내용은 C++ 복사/이동 생성자 정리 글을 참고하시기 바랍니다).

임베디드에서도 RAII를 쓸 수 있나요?

한 줄 답: 네, RAII는 힙 할당이나 예외 기능이 없어도(-fno-exceptions) 스택 객체의 스코프 종료 시마다 소멸자를 실행하므로 인터럽트 마스크나 GPIO 가드에 그대로 쓸 수 있습니다.

  • 힙과 예외가 없는 환경에서의 동작: RAII는 동적 메모리(힙)나 예외 처리에 의존하는 기법이 아닙니다. 예외를 끈 -fno-exceptions 빌드에서도 자동 저장 기간(스택) 객체의 소멸자는 함수 반환(return)이나 블록 종료 시마다 정상적으로 호출됩니다.
  • 임베디드 활용처: 힙을 쓰지 않고도 임계 구역 진입 시 인터럽트를 마스킹했다가 복원하거나, GPIO 핀 상태를 원래대로 되돌리는 스코프 가드 클래스로 활용할 수 있습니다.

개념 예시 (실행하지 않음, 레지스터/HAL 함수는 가상의 이름)

class IrqMaskGuard {
public:
    IrqMaskGuard()  { saved_ = irq_save_and_disable(); }  // hypothetical HAL call
    ~IrqMaskGuard() { irq_restore(saved_); }
    IrqMaskGuard(const IrqMaskGuard&) = delete;
    IrqMaskGuard& operator=(const IrqMaskGuard&) = delete;
private:
    unsigned saved_;
};
void update_shared_counter() {
    IrqMaskGuard g;      // interrupts masked
    ++shared_counter;
}                        // restored on every exit path

면접에서 RAII는 어떻게 물어보나요?

Q1. RAII(SBRM)의 핵심 규칙과 자원 해제 순서는 무엇인가요?

사용 전에 획득해야 하는 자원의 생명주기를 자동 저장 기간(또는 임시 수명) 객체의 수명에 묶는 것입니다. 생성자에서 자원을 획득(실패 시 예외 발생)하고 소멸자에서 예외 없이 해제하며, 스코프 종료나 예외로 인한 스택 되감기 시 **획득의 역순(in reverse order of acquisition)**으로 해제됩니다. 생성자 실행 도중 예외가 발생하면 이미 완전히 생성된 멤버와 기반 클래스만 초기화의 역순으로 해제됩니다.

Q2. open()/close()나 lock()/unlock()을 직접 호출하는 대신 RAII를 써야 하는 이유는 무엇인가요?

수동 호출 방식은 작업 중간에 조기 반환(early return)이나 예외가 발생하면 아래쪽의 해제 코드가 실행되지 않아 뮤텍스가 잠긴 채 남거나 메모리·파일이 누수됩니다. 반면 std::lock_guard, std::fstream, std::unique_ptr 같은 RAII 객체를 쓰면 어떤 경로로 스코프를 빠져나가든 소멸자가 호출되어 자원 해제가 보장됩니다.

Q3. 직접 RAII 클래스를 설계할 때 복사 생성자와 소멸자에서 주의할 점은 무엇인가요?

소멸자는 절대 예외를 던지면 안 되며(never throws), 두 객체가 동일한 자원을 중복해서 해제하지 않도록 복사 생성자와 복사 대입 연산자를 = delete로 금지해야 합니다(소유권 이전이 필요하면 이동만 허용 — 복사/이동 생성자 글 참고, 단일 인자 생성자는 explicit 권장 — explicit 글 참고).

Q4. 모든 자원에 RAII를 적용할 수 있나요? 힙이나 예외가 없는 임베디드에서도 동작하나요?

CPU 시간, 네트워크 대역폭, 스택 메모리처럼 사용 전에 획득 과정을 거치지 않는 자원에는 RAII가 적용되지 않습니다. 반면 힙이나 예외를 쓰지 않는(-fno-exceptions) 임베디드 빌드에서도 스택 객체의 소멸자는 함수 반환 시마다 호출되므로 인터럽트 마스크 가드 등에 그대로 사용할 수 있습니다.