1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <windows.h>
#include <iostream>
#include <vector>

void ProcessFileLegacy(const std::wstring& filename) {
    // 1. 파일 핸들 얻기
    HANDLE hFile = ::CreateFileW(
        filename.c_str(),
        GENERIC_READ,
        FILE_SHARE_READ,
        NULL,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL
    );

    if (hFile == INVALID_HANDLE_VALUE) {
        std::cerr << "Failed to open file. Error: " << ::GetLastError() << std::endl;
        return;
    }

    // 2. 파일 크기 얻기
    LARGE_INTEGER fileSize;
    if (!::GetFileSizeEx(hFile, &fileSize)) {
        ::CloseHandle(hFile); // 에러 시 수동 해제
        return;
    }

    // 3. 메모리 확보 및 읽기
    std::vector<char> buffer(fileSize.QuadPart);
    DWORD bytesRead = 0;
    
    if (!::ReadFile(hFile, buffer.data(), buffer.size(), &bytesRead, NULL)) {
        ::CloseHandle(hFile); // 에러 시 수동 해제
        return;
    }

    // --- 여기서 예외가 발생하는 처리가 있다고 가정 ---
    // 예: buffer 내용을 분석하는 함수가 std::runtime_error를 발생(Throw)
    // ParseBuffer(buffer); // 만약 예외가 날아가면, 아래의 CloseHandle은 호출되지 않고 누수된다!

    // 4. 리소스 수동 해제
    ::CloseHandle(hFile);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <windows.h>
#include <memory>

// HANDLE용 커스텀 삭제자
struct handle_deleter {
    // std::unique_ptr이 내부적으로 다룰 포인터 타입 지정
    using pointer = HANDLE; 

    void operator()(HANDLE handle) const noexcept {
        if (handle != nullptr && handle != INVALID_HANDLE_VALUE) {
            ::CloseHandle(handle);
        }
    }
};

// 안전한 핸들의 타입 별칭
using unique_handle = std::unique_ptr<void, handle_deleter>;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void ProcessFileModern(const std::wstring& filename) {
    // 확보한 직후 RAII 객체에 소유권을 넘긴다
    unique_handle hFile(::CreateFileW(
        filename.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL,
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL
    ));

    // 에러 체크 (INVALID_HANDLE_VALUE에 대한 대응은 후술)
    if (hFile.get() == INVALID_HANDLE_VALUE) {
        throw std::runtime_error("Failed to open file");
    }

    LARGE_INTEGER fileSize;
    if (!::GetFileSizeEx(hFile.get(), &fileSize)) {
        throw std::runtime_error("Failed to get file size");
    }

    std::vector<char> buffer(fileSize.QuadPart);
    DWORD bytesRead = 0;
    
    if (!::ReadFile(hFile.get(), buffer.data(), buffer.size(), &bytesRead, NULL)) {
        throw std::runtime_error("Failed to read file");
    }

    // 여기서 예외가 발생해도, 조기 리턴을 해도,
    // 함수를 빠져나가는 순간 unique_handle의 소멸자가 CloseHandle을 호출한다!
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <windows.h>
#include <memory>

struct win32_handle_traits {
    // 커스텀 포인터 타입 정의
    class pointer {
        HANDLE m_handle;
    public:
        // 기본 생성이나 nullptr 대입 시 INVALID_HANDLE_VALUE를 초기값으로 하는 설계도 가능하지만,
        // 범용성을 높이기 위해 nullptr과 INVALID_HANDLE_VALUE를 모두 무효 상태로 취급한다.
        pointer() noexcept : m_handle(nullptr) {}
        pointer(std::nullptr_t) noexcept : m_handle(nullptr) {}
        pointer(HANDLE h) noexcept : m_handle(h) {}
        
        // operator bool을 오버로딩하여 Win32의 2종류의 무효 값을 모두 거른다
        explicit operator bool() const noexcept {
            return m_handle != nullptr && m_handle != INVALID_HANDLE_VALUE;
        }
        
        operator HANDLE() const noexcept { return m_handle; }
        
        friend bool operator==(pointer a, pointer b) noexcept { return a.m_handle == b.m_handle; }
        friend bool operator!=(pointer a, pointer b) noexcept { return a.m_handle != b.m_handle; }
    };
    
    void operator()(pointer p) const noexcept {
        if (p) { // operator bool이 호출된다
            ::CloseHandle(p);
        }
    }
};

using safe_win32_handle = std::unique_ptr<void, win32_handle_traits>;

1
2
3
4
5

safe_win32_handle hFile(::CreateFileW(...));
if (!hFile) {
    // nullptr과 INVALID_HANDLE_VALUE 양쪽 모두 여기서 캐치할 수 있다!
    throw std::system_error(::GetLastError(), std::system_category(), "CreateFile failed");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// GDI 객체 삭제용 삭제자
struct gdi_deleter {
    using pointer = HGDIOBJ;
    void operator()(HGDIOBJ obj) const noexcept {
        if (obj != nullptr) {
            ::DeleteObject(obj);
        }
    }
};

using unique_gdi_obj = std::unique_ptr<void, gdi_deleter>;

// SelectObject의 RAII 래퍼 (스코프를 빠져나갈 때 원래의 객체를 복원한다)
class gdi_selector {
    HDC m_hdc;
    HGDIOBJ m_oldObj;

public:
    gdi_selector(HDC hdc, HGDIOBJ newObj) : m_hdc(hdc) {
        // 새로운 객체를 선택하고, 이전 객체를 저장
        m_oldObj = ::SelectObject(m_hdc, newObj);
    }

    ~gdi_selector() {
        if (m_oldObj != nullptr && m_oldObj != HGDI_ERROR) {
            // 스코프를 빠져나갈 때 자동 복원
            ::SelectObject(m_hdc, m_oldObj);
        }
    }

    // 복사 금지
    gdi_selector(const gdi_selector&) = delete;
    gdi_selector& operator=(const gdi_selector&) = delete;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

void DrawMyGraphics(HDC hdc) {
    // 펜 생성 (RAII 관리)
    unique_gdi_obj hPen(::CreatePen(PS_SOLID, 1, RGB(255, 0, 0)));
    
    {
        // 펜을 HDC에 선택 (스코프 관리)
        gdi_selector penSelect(hdc, hPen.get());
        
        // 그리기 처리...
        ::MoveToEx(hdc, 0, 0, NULL);
        ::LineTo(hdc, 100, 100);
        
        // 스코프를 빠져나갈 때 penSelect의 소멸자가 이전 펜을 SelectObject로 복원한다
    }
    
    // 함수를 빠져나갈 때 hPen의 소멸자가 DeleteObject를 호출한다
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class win32_srwlock {
    SRWLOCK m_lock;
public:
    win32_srwlock() noexcept {
        ::InitializeSRWLock(&m_lock);
    }
    
    // std::lock_guard가 요구하는 인터페이스
    void lock() noexcept {
        ::AcquireSRWLockExclusive(&m_lock);
    }
    void unlock() noexcept {
        ::ReleaseSRWLockExclusive(&m_lock);
    }
    
    // 복사·이동 금지
    win32_srwlock(const win32_srwlock&) = delete;
    win32_srwlock& operator=(const win32_srwlock&) = delete;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

win32_srwlock g_myLock;
int g_sharedData = 0;

void UpdateData() {
    // 예외 안전한 잠금 획득
    std::lock_guard<win32_srwlock> lock(g_myLock);
    
    g_sharedData++;
    if (g_sharedData > 100) {
        throw std::runtime_error("Overflow"); // 예외가 발생해도 안전하게 잠금 해제!
    }
}

1
2
3
4
5
6
7

inline void throw_if_win32_error(BOOL result, const char* msg = "Win32 API failed") {
    if (!result) {
        DWORD err = ::GetLastError();
        // std::system_category는 FormatMessage API를 내부에서 호출하여, 에러 문자열을 생성해 준다
        throw std::system_error(err, std::system_category(), msg);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <expected>
#include <string>

// 성공 시에는 unique_handle, 실패 시에는 DWORD(에러 코드)를 반환한다
std::expected<safe_win32_handle, DWORD> OpenFileModern(const std::wstring& path) {
    safe_win32_handle h(::CreateFileW(
        path.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr));
        
    if (!h) {
        return std::unexpected(::GetLastError());
    }
    return std::move(h); // 성공 시에는 핸들을 이동(move)하여 반환
}

void Usage() {
    auto result = OpenFileModern(L"C:\\test.txt");
    if (result) {
        // 성공 시 처리
        safe_win32_handle& hFile = *result;
        // ...
    } else {
        // 실패 시 처리
        DWORD err = result.error();
        std::cerr << "Error code: " << err << std::endl;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include <wil/resource.h>
#include <wil/result.h>

void ProcessWithWIL() {
    // wil::unique_handle은 INVALID_HANDLE_VALUE와 NULL 양쪽 모두 대응되어 있음
    wil::unique_handle hFile;
    
    // THROW_IF_WIN32_BOOL_FALSE 매크로가 에러 체크와 예외 발생을 자동화
    THROW_IF_WIN32_BOOL_FALSE(
        ::CreateFileW(L"test.txt", GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr),
        hFile.put() // WIL 특유의 출력 포인터 수신용 헬퍼
    );
    
    // wil::unique_cotaskmem_string 등 메모리 관리 래퍼도 충실
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include <winrt/base.h>

void ComExample() {
    // COM 초기화 (RAII화)
    winrt::init_apartment();

    // IUnknown을 상속하는 COM 인터페이스를 winrt::com_ptr로 안전하게 관리
    winrt::com_ptr<IDXGIFactory> factory;
    winrt::check_hresult(
        ::CreateDXGIFactory(__uuidof(IDXGIFactory), factory.put_void())
    );
    
    // AddRef나 Release를 수동으로 호출할 필요가 전혀 없다
}