In many real-world applications, you may need to log information about exceptions before allowing them to propagate further up the call stack. This helps with debugging and monitoring, while still allowing higher-level code to make decisions about how to handle the error. Your challenge is to write a function that catches an exception, logs a specific message, and then rethrows the same exception so that it can be handled elsewhere.


#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>


#include <sstream>
#include <iostream>
#include <functional>
#include <stdexcept>

void logAndRethrow(const std::function<void()>& func);

TEST_CASE("logAndRethrow logs and rethrows std::runtime_error", "[logAndRethrow]") {
    std::streambuf* oldCout = std::cout.rdbuf();
    std::ostringstream oss;
    std::cout.rdbuf(oss.rdbuf());
    
    bool caught = false;
    try {
        logAndRethrow([]() {
            throw std::runtime_error("Test error");
        });
    } catch (const std::runtime_error& ex) {
        caught = true;
        REQUIRE(std::string(ex.what()) == "Test error");
    }
    std::cout.rdbuf(oldCout);
    std::string output = oss.str();
    REQUIRE(caught);
    REQUIRE(output.find("Exception caught and logged") != std::string::npos);
}

TEST_CASE("logAndRethrow does not log if no exception is thrown", "[logAndRethrow]") {
    std::streambuf* oldCout = std::cout.rdbuf();
    std::ostringstream oss;
    std::cout.rdbuf(oss.rdbuf());
    
    REQUIRE_NOTHROW(logAndRethrow([]() { /* nothing thrown */ }));
    std::cout.rdbuf(oldCout);
    std::string output = oss.str();
    REQUIRE(output.find("Exception caught and logged") == std::string::npos);
}

TEST_CASE("logAndRethrow rethrows non-std::exception types", "[logAndRethrow]") {
    std::streambuf* oldCout = std::cout.rdbuf();
    std::ostringstream oss;
    std::cout.rdbuf(oss.rdbuf());
    bool caught = false;
    try {
        logAndRethrow([]() {
            throw 42;
        });
    } catch (int val) {
        caught = true;
        REQUIRE(val == 42);
    }
    std::cout.rdbuf(oldCout);
    std::string output = oss.str();
    REQUIRE(caught);
    REQUIRE(output.find("Exception caught and logged") != std::string::npos);
}

TEST_CASE("logAndRethrow can be called multiple times", "[logAndRethrow]") {
    std::streambuf* oldCout = std::cout.rdbuf();
    std::ostringstream oss;
    std::cout.rdbuf(oss.rdbuf());
    int count = 0;
    for (int i = 0; i < 3; ++i) {
        try {
            logAndRethrow([i]() {
                if (i % 2 == 0) throw std::runtime_error("Even!");
            });
        } catch (const std::runtime_error&) {
            ++count;
        }
    }
    std::cout.rdbuf(oldCout);
    std::string output = oss.str();
    REQUIRE(count == 2);
    size_t pos = 0;
    int found = 0;
    while ((pos = output.find("Exception caught and logged", pos)) != std::string::npos) {
        ++found;
        ++pos;
    }
    REQUIRE(found == 2);
}

TEST_CASE("logAndRethrow allows exception to propagate to outer catch", "[logAndRethrow]") {
    bool handled = false;
    try {
        logAndRethrow([]() {
            throw std::logic_error("Outer error");
        });
    } catch (const std::logic_error& ex) {
        handled = true;
        REQUIRE(std::string(ex.what()) == "Outer error");
    }
    REQUIRE(handled);
}

test.cpp

A practical course on mastering exception handling in modern C++. Learn how to write robust code by detecting, throwing, and managing errors using exceptions. Each section introduces a new aspect of exception handling, followed by hands-on challenges inspired by real-world scenarios.

Understand the basics of exception handling in C++. Learn about try-catch blocks, throw statements, and the standard exception hierarchy.

Learn how to define and use your own exception classes for more descriptive error handling.

Discover how to write exception-safe code and manage resources properly using RAII.

Explore advanced techniques such as exception propagation, rethrowing, and exception specifications.

Challenge: Logging and Rethrowing

解答