C++ noexcept 지정자 | "예외 명세" 가이드

noexcept란?

함수가 예외를 던지지 않음을 명시

void func() noexcept {
    // 예외 던지지 않음
}

void func2() noexcept(true) {
    // 예외 던지지 않음
}

void func3() noexcept(false) {
    // 예외 던질 수 있음 (기본값)
}

noexcept의 장점

// 1. 컴파일러 최적화
void swap(int& a, int& b) noexcept {
    int temp = a;
    a = b;
    b = temp;
}

// 2. 이동 생성자 최적화
class MyClass {
public:
    MyClass(MyClass&&) noexcept {
        // vector 등에서 이동 사용
    }
};

// 3. 명확한 계약
int calculate(int x) noexcept {
    return x * 2;  // 예외 없음 보장
}

조건부 noexcept

template<typename T>
void swap(T& a, T& b) noexcept(noexcept(T(std::move(a)))) {
    T temp(std::move(a));
    a = std::move(b);
    b = std::move(temp);
}

// 간단한 버전
template<typename T>
void swap(T& a, T& b) noexcept(std::is_nothrow_move_constructible<T>::value) {
    // ...
}

실전 예시

예시 1: 이동 생성자

class String {
private:
    char* data;
    size_t length;
    
public:
    String(const char* str) {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
    }
    
    ~String() {
        delete[] data;
    }
    
    // 복사 생성자 (예외 가능)
    String(const String& other) {
        length = other.length;
        data = new char[length + 1];  // 예외 가능
        strcpy(data, other.data);
    }
    
    // 이동 생성자 (noexcept)
    String(String&& other) noexcept 
        : data(other.data), length(other.length) {
        other.data = nullptr;
        other.length = 0;
    }
    
    // 이동 대입 연산자 (noexcept)
    String& operator=(String&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            length = other.length;
            other.data = nullptr;
            other.length = 0;
        }
        return *this;
    }
};

예시 2: swap 함수

template<typename T>
void swap(T& a, T& b) noexcept {
    T temp(std::move(a));
    a = std::move(b);
    b = std::move(temp);
}

class MyClass {
private:
    int* data;
    
public:
    MyClass(int value) : data(new int(value)) {}
    
    ~MyClass() {
        delete data;
    }
    
    // swap (noexcept)
    friend void swap(MyClass& a, MyClass& b) noexcept {
        using std::swap;
        swap(a.data, b.data);
    }
};

예시 3: 소멸자

class Resource {
private:
    int* data;
    
public:
    Resource(int value) : data(new int(value)) {}
    
    // 소멸자는 기본적으로 noexcept
    ~Resource() noexcept {
        delete data;
        // 예외 던지면 안됨!
    }
};

예시 4: 벡터 최적화

#include <vector>

class Widget {
public:
    Widget() = default;
    
    // noexcept 없으면 vector가 복사 사용
    Widget(Widget&& other) {
        // ...
    }
    
    // noexcept 있으면 vector가 이동 사용
    Widget(Widget&& other) noexcept {
        // ...
    }
};

int main() {
    std::vector<Widget> vec;
    
    // vec.push_back()나 vec.resize() 시
    // noexcept 이동 생성자가 있으면 이동 사용
    // 없으면 복사 사용 (예외 안전성)
}

noexcept 연산자

// noexcept 연산자: 표현식이 예외를 던지는지 확인
void func1() noexcept {}
void func2() {}

int main() {
    std::cout << noexcept(func1()) << std::endl;  // 1 (true)
    std::cout << noexcept(func2()) << std::endl;  // 0 (false)
    
    std::cout << noexcept(1 + 2) << std::endl;    // 1
    std::cout << noexcept(throw 1) << std::endl;  // 0
}

자주 발생하는 문제

문제 1: noexcept 위반

void func() noexcept {
    throw std::runtime_error("에러");  // std::terminate 호출!
}

int main() {
    try {
        func();
    } catch (...) {
        // 여기 도달 안함
        // std::terminate가 먼저 호출됨
    }
}

문제 2: 조건부 noexcept 누락

// ❌ 항상 noexcept (잘못됨)
template<typename T>
void process(T value) noexcept {
    T copy = value;  // T의 복사 생성자가 예외 던질 수 있음
}

// ✅ 조건부 noexcept
template<typename T>
void process(T value) noexcept(std::is_nothrow_copy_constructible<T>::value) {
    T copy = value;
}

문제 3: 소멸자 예외

// ❌ 소멸자에서 예외
class BadClass {
public:
    ~BadClass() {
        throw std::runtime_error("에러");  // 위험!
    }
};

// ✅ 소멸자는 noexcept
class GoodClass {
public:
    ~GoodClass() noexcept {
        try {
            // 예외 발생 가능한 코드
        } catch (...) {
            // 예외 처리
        }
    }
};

문제 4: 이동 생성자 noexcept 누락

// ❌ noexcept 없음 (vector가 복사 사용)
class MyClass {
public:
    MyClass(MyClass&& other) {
        // ...
    }
};

// ✅ noexcept 추가 (vector가 이동 사용)
class MyClass {
public:
    MyClass(MyClass&& other) noexcept {
        // ...
    }
};

noexcept와 성능

#include <vector>
#include <chrono>

class Widget {
    int* data;
    
public:
    Widget(int value) : data(new int(value)) {}
    
    ~Widget() {
        delete data;
    }
    
    // noexcept 없음
    Widget(Widget&& other) 
        : data(other.data) {
        other.data = nullptr;
    }
    
    // noexcept 있음
    Widget(Widget&& other) noexcept 
        : data(other.data) {
        other.data = nullptr;
    }
};

int main() {
    std::vector<Widget> vec;
    
    // noexcept 있으면 이동 (빠름)
    // noexcept 없으면 복사 (느림)
    for (int i = 0; i < 1000000; i++) {
        vec.push_back(Widget(i));
    }
}

사용 권장사항

// ✅ noexcept 사용 권장
// 1. 이동 생성자/대입 연산자
MyClass(MyClass&&) noexcept;
MyClass& operator=(MyClass&&) noexcept;

// 2. swap 함수
void swap(MyClass&, MyClass&) noexcept;

// 3. 소멸자 (기본적으로 noexcept)
~MyClass() noexcept;

// 4. 간단한 getter
int getValue() const noexcept;

// ❌ noexcept 사용 지양
// 1. 예외 던질 수 있는 함수
void process() {
    // 예외 가능
}

// 2. 불확실한 경우
void complexOperation() {
    // 나중에 예외 추가될 수 있음
}

FAQ

Q1: noexcept는 언제 사용?

A:

• 이동 생성자/대입
• swap 함수
• 소멸자
• 예외 없음 보장

Q2: noexcept 위반 시?

A: std::terminate 호출. 프로그램 종료.

Q3: 성능 이점?

A:

• 컴파일러 최적화
• vector 이동 사용
• 스택 언와인딩 불필요

Q4: 조건부 noexcept?

A: noexcept(표현식). 템플릿에서 유용.

Q5: 소멸자는?

A: 기본적으로 noexcept. 예외 던지면 안됨.

Q6: noexcept 학습 리소스는?

A:

• “Effective Modern C++”
• cppreference.com
• “C++ Primer”

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ noexcept | “예외 없음 지정” 가이드
• C++ Exception Specifications | “예외 명세” 가이드
• C++ Move Constructor | “이동 생성자” 가이드

관련 글

• C++ noexcept 키워드 |
• C++ noexcept 완벽 가이드 | 예외 계약·이동 최적화·프로덕션 패턴 [#42-1]
• C++ async & launch |
• C++ Atomic Operations |
• C++ Attributes |