예외 던지기

#include <iostream>

void divide(int a, int b) {
    if (b == 0) {
        throw 100; // int 타입의 에러 코드 던지기
    }
    std::cout << "Result: " << a / b << std::endl;
}

void processFile(const char* filename) {
    if (filename == nullptr || filename[0] == '\0') {
        throw "Filename cannot be empty!"; // const char* (C-스타일 문자열) 던지기
    }
    // 실제 파일 처리 로직...
    std::cout << "File '" << filename << "' processed successfully.\n";
}

int main() {
    try {
        divide(10, 0);
    } catch (int e) {
        std::cerr << "Caught integer error code: " << e << std::endl;
    }

    try {
        processFile("");
    } catch (const char* msg) {
        std::cerr << "Caught string error: " << msg << std::endl;
    }
    return 0;
}

#include <iostream>
#include <string>

void connectToServer(const std::string& address) {
    if (address.empty()) {
        throw std::string("Connection Error: Server address is empty!"); // std::string 객체 던지기
    }
    // 실제 연결 로직...
    std::cout << "Connected to " << address << std::endl;
}

int main() {
    try {
        connectToServer("");
    } catch (const std::string& e) {
        std::cerr << "Connection Failed: " << e << std::endl;
    }
    return 0;
}

#include <iostream>
#include <stdexcept> // std::invalid_argument, std::out_of_range, std::runtime_error
#include <vector>

void process_data(int data) {
    if (data < 0) {
        throw std::invalid_argument("Data cannot be negative."); // 논리 오류
    }
    if (data > 100) {
        throw std::out_of_range("Data is too large, must be <= 100."); // 범위 오류
    }
    std::cout << "Data processed: " << data << std::endl;
}

void simulate_hardware_failure() {
    bool failure_detected = true; // 실제로는 하드웨어 상태를 검사
    if (failure_detected) {
        throw std::runtime_error("Hardware malfunction detected!"); // 런타임 오류
    }
    std::cout << "Hardware operating normally.\n";
}

int main() {
    // std::invalid_argument 예외 처리
    try {
        process_data(-5);
    } catch (const std::invalid_argument& e) {
        std::cerr << "Caught invalid_argument: " << e.what() << std::endl;
    }

    // std::out_of_range 예외 처리
    try {
        process_data(150);
    } catch (const std::out_of_range& e) {
        std::cerr << "Caught out_of_range: " << e.what() << std::endl;
    }

    // std::runtime_error 예외 처리
    try {
        simulate_hardware_failure();
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught runtime_error: " << e.what() << std::endl;
    }

    // 일반 std::exception으로 모든 표준 예외를 잡기
    try {
        // 다시 던져서 테스트
        // process_data(-10); // 주석 해제 시 위에서 잡힘
        std::vector<int> v(5);
        v.at(10) = 1; // std::out_of_range 발생
    } catch (const std::exception& e) { // std::out_of_range는 std::exception을 상속하므로 여기서 잡힘
        std::cerr << "Caught generic std::exception: " << e.what() << std::endl;
    }

    return 0;
}

// MyCustomException.h (예시, 다음 장에서 자세히)
#include <iostream>
#include <stdexcept>
#include <string>

class MyCustomException : public std::runtime_error {
public:
    MyCustomException(const std::string& message)
        : std::runtime_error(message) {}
};

// 사용 예시
void process_network_packet(int packet_size) {
    if (packet_size < 10) {
        throw MyCustomException("Packet size is too small.");
    }
    if (packet_size > 1024) {
        throw MyCustomException("Packet size exceeds maximum limit.");
    }
    std::cout << "Packet processed, size: " << packet_size << std::endl;
}

int main() {
    try {
        process_network_packet(5);
    } catch (const MyCustomException& e) {
        std::cerr << "Caught custom exception: " << e.what() << std::endl;
    } catch (const std::exception& e) { // MyCustomException도 std::exception을 상속하므로 여기서도 잡힐 수 있음
        std::cerr << "Caught general exception: " << e.what() << std::endl;
    }
    return 0;
}