Home > Backend Development > C++ > body text

Why doesn\'t C use nested exceptions to handle exceptions thrown from destructors?

Barbara Streisand
Release: 2024-11-01 01:29:02
Original
376 people have browsed it

Why doesn't C   use nested exceptions to handle exceptions thrown from destructors?

Why doesn't C use nested exceptions to throw from destructors?

Understanding the Issue

Throwing exceptions from destructors introduces a dilemma: what to do when an exception is already in flight? Overwriting the existing exception or nesting the new exception within the existing one are potential solutions, but it was decided that terminating with std::terminate would be the standard approach.

Consideration of Nested Exceptions

C 11 introduced the std::nested_exception feature, which could potentially address the issue by nesting the old exception within the new one. However, this idea was not implemented.

Reasons for Non-Implementation

One reason for not using nested exceptions in this context is the fact that std::nested_exception has very limited usage, with only one known practical application: creating fully-annotated call stacks.

This example demonstrates how nesting exceptions provides a convenient way to add context and pinpoint errors during debugging:

<code class="cpp">#include <iostream>
#include <sstream>
#include <exception>

void rethrow(const std::string& context, ...) {
    std::ostringstream ss;
    ss << context;
    auto sep = " : ";
    (void) ((ss << sep << args), sep = ", ", 0)...);
    try {
        std::rethrow_exception(std::current_exception());
    } catch(const std::invalid_argument& e) {
        std::throw_with_nested(std::invalid_argument(ss.str()));
    } catch(const std::logic_error& e) {
        std::throw_with_nested(std::logic_error(ss.str()));
    } catch(...) {
        std::throw_with_nested(std::runtime_error(ss.str()));
    }
}

int main() {
    try {
        outer("xyz");
        outer("abcd");
    } catch(std::exception& e) {
        print_exception(e);
    }
    return 0;
}

void print_exception(const std::exception& e, std::size_t depth = 0) {
    std::cerr << "exception: " << std::string(depth, ' ') << e.what() << '\n';
    try {
        std::rethrow_if_nested(e);
    } catch (const std::exception& nested) {
        print_exception(nested, depth + 1);
    }
}</code>
Copy after login

Expected Output:

exception: outer : abcd
exception:  inner : abcdabcd
exception:   really_inner
exception:    too long
Copy after login

The above example showcases the nesting of exceptions and demonstrates how this technique aids in tracing errors and understanding call stacks.

Despite the utility of nested exceptions in this specific scenario, the decision not to use them in the context of destructor exceptions was likely made due to the ease and reliability of terminating with std::terminate.

The above is the detailed content of Why doesn\'t C use nested exceptions to handle exceptions thrown from destructors?. For more information, please follow other related articles on the PHP Chinese website!

source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Latest Articles by Author
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
About us Disclaimer Sitemap
php.cn:Public welfare online PHP training,Help PHP learners grow quickly!