Làm cách nào để giải phóng bộ nhớ trong các khối try-catch?

Question

Tôi có một câu hỏi đơn giản hy vọng - làm thế nào một bộ nhớ miễn phí được phân bổ trong khối thử khi ngoại lệ xảy ra? Hãy xem xét mã sau đây:

try 
{ 
    char *heap = new char [50]; 
     //let exception occur here 
    delete[] heap; 
} 
catch (...) 
{ 
    cout << "Error, leaving function now"; 
    //delete[] heap; doesn't work of course, heap is unknown to compiler 
    return 1; 
} 

Làm cách nào tôi có thể giải phóng bộ nhớ sau khi phân bổ vùng heap và ngoại lệ trước khi gọi delete[] heap? Có một quy tắc không để cấp phát bộ nhớ trên heap trong các thử .. bắt khối?

Answer 1

Nghiên cứu Thành ngữ RAII (Mua tài nguyên là khởi tạo)! Xem ví dụ số Wikipedia article on RAII.

RAII chỉ là ý tưởng chung. Nó được sử dụng ví dụ: trong các lớp mẫuhoặc std::shared_ptr của thư viện chuẩn C++.

---

giải thích Rất ngắn gọn về các thành ngữ RAII:

Về cơ bản, nó là ++ phiên bản C của try..finally khối được tìm thấy trong một số ngôn ngữ khác. Thành ngữ RAII được cho là linh hoạt hơn.

Nó hoạt động như thế này:

• Bạn viết một lớp bao bọc xung quanh tài nguyên của bạn (ví dụ bộ nhớ). Trình hủy có trách nhiệm giải phóng tài nguyên.

• Bạn tạo, dưới dạng biến cục bộ (tự động), một thể hiện của lớp trình bao bọc trong phạm vi. Sau khi thực hiện chương trình rời khỏi phạm vi đó, hàm hủy của đối tượng sẽ được gọi, do đó giải phóng tài nguyên (ví dụ: bộ nhớ).

Điều quan trọng là rằng nó không quan trọng như thế nào phạm vi được kết thúc. Ngay cả khi một ngoại lệ được ném, phạm vi vẫn còn thoát và destructor của đối tượng bao bọc vẫn được gọi.

---

dụ Rất thô:

// BEWARE: this is NOT a good implementation at all, but is supposed to 
// give you a general idea of how RAII is supposed to work: 
template <typename T> 
class wrapper_around 
{ 
    public: 
    wrapper_around(T value) 
     : _value(value) 
    { } 
    T operator *() 
    { 
     return _value; 
    } 
    virtual ~wrapper_around() 
    { 
     delete _value; // <-- NOTE: this is incorrect in this particular case; 
         // if T is an array type, delete[] ought to be used 
    } 
    private: 
    T _value; 
}; 
// ... 

{ 
    wrapper_around<char*> heap(new char[50]); 
    // ... do something ... 

    // no matter how the { } scope in which heap is defined is exited, 
    // if heap has a destructor, it will get called when the scope is left. 
    // Therefore, delegate the responsibility of managing your allocated 
    // memory to the `wrapper_around` template class. 
    // there are already existing implementations that are much better 
    // than the above, e.g. `std::unique_ptr` and `std::shared_ptr`! 
} 

Answer 2

Hoặc di chuyển new trước try, do đó con trỏ vẫn còn trong phạm vi, hoặc sử dụng một con trỏ thông minh như shared_ptr hoặc unique_ptr (trong một pinch , auto_ptr, nhưng nó có vấn đề) sẽ làm sạch cho bạn khi thoát. Ngoại lệ là một lý do rất lớn tại sao con trỏ thông minh lại quan trọng.

Answer 3

Cách dễ nhất là khai báo biến trước khối thử và sau đó chỉ cần khởi tạo trong khối.

Answer 4

Đồng ý với câu trả lời trên RAII và con trỏ thông minh.

Tuy nhiên, nếu bạn nhấn mạnh, bạn có thể làm điều này:

try { dangerous operations } 
catch { cleanup; throw; } 

Answer 5

OK mister Java lập trình viên:

try 
{ 
    // Exception safe dynamic allocation of a block of memory. 
    std::vector<char> heap(50); 

    // DO STUFF 

    // Note in C++ we use stack based objects and their constructor/destructor 
    // TO give a deterministic cleanup, even in the presence of exceptions. 
    // 
    // Look up RAII (bad name for a fantastic concept). 
} 
catch (...) 
{ 
    cout << "Error, leaving function now"; 
    return 1; // Though why you want to return when you have not fixed the exception is 
       // slightly strange. Did you want to rethrow? 
} 

Answer 6

Câu trả lời 'đúng' là RAII và shared_ptr như đã đề cập ở trên, nhưng chỉ để được hoàn thành: trong ví dụ của bạn, bạn có thể thay thế

char *heap = new char [50]; 

với

char *stack = static_cast<char*>(alloca(50)); 

alloca là gần như giống hệt nhau để malloc, ngoại trừ việc nó alocs bộ nhớ trên stack thay vì đống, vì vậy không vấn đề làm thế nào bạn có chức năng thoát (ném hoặc bây giờ), bộ nhớ sẽ được khai hoang, và không xóa hoặc giải phóng là cần thiết.

Answer 7

Tôi phải đồng ý với tất cả những người đã nói RAII, tuy nhiên, tôi sẽ sử dụng Boost shared_array thay vì auto_ptr. Gọi con trỏ tự động delete và không phải 'xóa []' sẽ gây ra rò rỉ với một mảng.

Answer 8

Câu trả lời chung là sử dụng RAII.

Tuy nhiên, có thể của nó để giải quyết nó bằng cách di chuyển biến ra khỏi try {scope}:

char * heap = NULL; 
try { 
    heap = new char [50]; 
    ... stuff ... 
} catch (...) { 
    if (heap) { 
    delete[] heap; 
    heap = NULL; 
    } 
    ... however you want to handle the exception: rethrow, return, etc ... 
} 

Xin lưu ý rằng tôi không đề xuất này như một thói quen tốt - nhưng nhiều hơn một xuống & bẩn chỉ được sử dụng nếu bạn thực sự biết những rủi ro và vẫn sẵn sàng đưa họ. Cá nhân, tôi sẽ sử dụng RAII.

Hòa bình

Answer 9

Có - nếu bạn đang xem xét sự đơn giản - con trỏ nằm ngoài khối thử của bạn là giải pháp.

Kính trọng