Ngoại lệ trong destructor

Question

Trong destructor của tôi, tôi phải làm sạch một vài tài nguyên. Giả sử tôi có ba cuộc gọi để xóa tài nguyên có thể ném. Vì nó không phải là tốt cho phép một ngoại lệ để lại một destructor, những gì nên được mẫu thiết kế của tôi? Rõ ràng cách dưới đây không thể mở rộng được.

Cảm ơn.

class B::~B(){ 

try{ 
    clearResourceA() 
} 
catch{ 
    try{ 
     clearResourceB(); 
     } 
    catch{ 
     clearResourceC(); 
    } 
    clearResourceC(); 
} 
clearResourceB(); 
    . 
    . 
} 

Answer 1

Chụp bất kỳ thứ gì có thể ném vào phá hủy của bạn với một nắm bắt (tức là, bắt (...)) và cố hết sức để xử lý các trường hợp ngoại lệ được ném. Hãy chắc chắn rằng không có ngoại lệ lan truyền ra khỏi destructor, mà catch-all sẽ giúp bạn ngăn chặn.

Answer 2

Tại sao không:

try{clearResourceA();} catch(...){} 
try{clearResourceB();} catch(...){} 
try{clearResourceC();} catch(...){} 

Answer 3

try 
{ 
    ClearResourceA(); 
} 
catch(...) 
{ 
    ExceptionWasThrown(); 
} 
try 
{ 
    ClearResourceB(); 
} 
catch(...) 
{ 
    ExceptionWasThrown(); 
} 
... 

Answer 4

đóng gói mỗi tài nguyên trong một lớp học mà xóa chúng trong destructor của nó (với một thử xung quanh/catch):

struct ProperlyManagedA { 
    // some means of using the resource - a rudimentary way is this: 
    A &getA() { return a; } 
    const A &getA() const { return a; } 
    // cleanup 
    ~ProperlyManagedA() { 
     try { 
      a.clear(); // whatever it is ClearResourceA actually does 
     } catch (...) {} 
    } 
    private: 
    A a; 
} 

Một shared_ptr với một tuỳ chỉnh deleter là một cách để đạt được điều này mà không cần phải tạo toàn bộ lớp cho từng loại tài nguyên.

Bạn có thể cải thiện việc loại bỏ ngoại lệ (ví dụ: ghi nhật ký sự cố), tùy thuộc vào nội dung được ném.

Thậm chí tốt hơn, sửa đổi tài nguyên A, B và C để chúng tự rõ ràng trong các trình phá hủy của riêng chúng. Điều đó có thể là không thể, mặc dù.

Dù bằng cách nào, bạn có thể đặt nhiều tài nguyên như vậy vào một lớp đơn tùy ý, mà không thêm bất kỳ mã nào vào trình phá hủy của lớp. Đây là "khả năng mở rộng". Toàn bộ quan điểm của RAII, là mỗi người dùng của một tài nguyên không cần phải viết mã dọn dẹp để sử dụng tài nguyên một cách chính xác.

Answer 5

Bạn cũng có thể bọc các hàm ClearResources của mình để đảm bảo chúng không bao giờ ném. Tại sao họ có thể ném đi?

Answer 6

Vì bạn đã hỏi về mẫu thiết kế Tôi sẽ nói quy tắc ngón tay cái nào tôi sử dụng với thành công. Tất cả chức năng có chức năng dọn sạch/chấm dứt nên KHÔNG BAO GIỜ ném.

tên Những chức năng thường cũng công nhận:

• rõ ràng *()
• sạch *()
• Chấm dứt *()
• Phá hủy *()
• phát hành *()
• Detach *()
• Miễn phí *()
• Xóa *()
• ~ Destructor()
• ...

Lý do mà đứng đằng sau này là:

• có phải ít nhất 1 chức năng cho mỗi tài nguyên mà đảm bảo rằng tài nguyên cụ thể sẽ bị xóa
• (đệ quy) nếu bạn xây dựng clean- lên chức năng và bạn phát hành nhiều tài nguyên sau đó chỉ sử dụng các chức năng mà đảm bảo rằng các tài nguyên này sẽ được phát hành theo cách ngoại lệ an toàn
• lập trình viên sử dụng yo mã ur phải có cách để làm sạch-up tài nguyên
• nếu bạn xuất chức năng dọn dẹp bên ngoài thư viện thì đừng tuyên truyền ngoại lệ (vì người sử dụng thư viện sẽ không biết nếu tài nguyên được giải phóng)

Và tôi có thể thử sử dụng RAII pattern. Nhưng ngay cả trong trường hợp này, các quy tắc trên sẽ được sử dụng.