Ngoại lệ trong các trường hợp ngoại lệ trong C++

Question

Khi làm việc với C# hoặc Java, tôi đã sử dụng để tạo các lớp ngoại lệ bao gồm các ngoại lệ khác với tư cách thành viên lớp. Ví dụ:

public class MyException : Exception { 
    private MyException ex; 
    private String message; 

    public String what() { 
     return this.message; 
    } 

    public String stack() { 
     if(ex != null) { 
      StringBuilder s; 
      s.append(this.what()); 
      s.append(this.ex.stack()); 
      return s.toString(); 
     } 

     return this.what(); 
    } 
} 

Tôi đang tìm các ví dụ về cùng một chủ đề nhưng đối với C++ và tôi không thể tìm thấy (có thể tôi không tìm kiếm đúng cụm từ, bạn có thể thấy tiêu đề của câu hỏi này không phải là rất ưa thích).

Dù sao, cách chính xác để thực hiện điều đó trong C++ là gì? Là nó để lưu trữ các ngoại lệ bên trong như một con trỏ hoặc một tài liệu tham khảo? (Tôi nghĩ rằng tôi có thể cần một con trỏ để nó có thể là null khi nó là ngoại lệ đầu tiên). Khi tôi đưa ra ngoại lệ, nó có phải là con trỏ được tạo với new không?

EDIT: Có thể những gì tôi đã viết là một chút bối rối hoặc không phải là một thực hành lập trình nổi tiếng (được chấp nhận). Vì vậy, tôi sẽ chỉ định làm thế nào tôi có ý định sử dụng lớp này với một đoạn:

try { 
    // Code that throws an exception of type MyException 
} catch(MyException ex) { 
    MyException another = new MyException(); 
    another.setEx(ex); 
    another.setMessage("A message that explains where the other exception was caught and on what conditions"); 

    throw another; 
} 

Answer 1

Tôi không nghĩ rằng chúng ta cần một tài sản lớp dụ (ví dụ ex) trong Java/C#/C++ nếu lớp học của bạn không được thiết kế trong mẫu đơn. Ngoài ra, here là một hướng dẫn mà bạn có thể muốn xem.

Answer 2

Không có cách nào đúng để làm điều đó với các ngoại lệ tiêu chuẩn trong C++ 03 vì chúng được thiết kế để sử dụng đa hình nhưng không thể nhân bản. Vì vậy, nếu bạn bắt giữ std::exception const& e bạn có thể lưu trữ một bản sao nhưng điều này sẽ dẫn đến việc cắt, mất tất cả thông tin hữu ích. Bạn nên không lưu trữ một con trỏ hoặc tham chiếu đến ngoại lệ vì thời gian tồn tại của nó sẽ kết thúc ngay sau khi rời khỏi mệnh đề catch (giả sử bạn không trả lại ngoại lệ ban đầu).

Bạn có thể vượt qua giới hạn này nếu bạn biết từng loại có thể được ném và thử nghiệm tất cả nhưng đó không phải là thiết kế đẹp (tức là nó chuyển đổi đa hình). Nó có ý nghĩa hơn để viết một lớp ngoại lệ cơ bản của riêng bạn mà có thể được nhân bản và bắt nó. Tuy nhiên, bạn vẫn gặp sự cố nếu bạn bắt gặp một số std::exception đến từ mã của người khác.

Tại thời điểm này, tôi cảm thấy bắt buộc phải đề cập đến Boost.Exception. Nó làm cho nó dễ dàng để viết hệ thống phân cấp ngoại lệ của riêng bạn và cung cấp các tiện ích khác nhau, trong số đó boost::exception_ptr. Sau đó bạn có thể làm:

typedef boost::error_info<struct tag_nested_exception, boost::exception_ptr> 
    nested_exception; 

// ... 
catch(...) { 
    // better: use BOOST_THROW_EXCEPTION 
    throw your_exception_type() << nested_exception(boost::current_exception()); 
} 

này rất hữu ích mà boost::diagnostic_info hỗ trợ nó và sẽ hiển thị ngoại trừ lồng nhau cho bạn (đó là không có giấy tờ). Thậm chí còn được đề xuất rằng nested_exceptiontypedef này cũng phải là một phần của thư viện; trong khi đó, thật dễ dàng để tự viết nó.

Đừng mong đợi phép thuật: boost::current_exception 'chụp' ngoại lệ hoạt động (chữ in hoa: hoặc bản sao của nó) chỉ phạt nếu trang web ném sử dụng boost::enable_current_exception. (Về mặt chức năng, đây là tương đương về mặt đạo đức của việc sử dụng một lớp ngoại lệ cơ bản có thể được nhân bản). Nếu không, nó sẽ không thất bại nhưng một số thông tin có thể bị mất.

---

Lưu ý cuối cùng, biết rằng thiết kế Boost.Exception được chấp nhận cho C++ 0x.Do đó, sau một cách chính xác lưu trữ các ngoại lệ hoạt động, với không có boost::current_exception hãy cẩn thận vì nó có hỗ trợ ngôn ngữ:

// you can still use Boost.Exception: 
typedef boost::error_info<struct tag_nested_exception, std::exception_ptr> 
    nested_exception; 

// ... 
catch(...) { 
    // e has type std::exception_ptr 
    auto e = std::current_exception(); 
    // internally store the std::exception_ptr 
    throw your_exception_type(e); 

    // or with Boost 
    BOOST_THROW_EXCEPTION(your_exception_type() << nested_exception(e)); 
} 

Ngoài ra còn có một loại std::nested_exception rằng có thể dễ dàng được sử dụng như sau:

catch(...) { 
    // throws an unspecified type derived from your_exception_type 
    // and std::nested_exception 
    std::throw_with_nested(your_exception_type()); 
} 

Answer 3

Tôi đoán bạn có thể ném unique_ptr<some_exception>, sau đó thực hiện inner_exception một unique_ptr khác có quyền sở hữu.