Điều gì đang xảy ra trong khi xóa câu lệnh `delete this; '?

Question

Hãy xem xét đoạn mã sau:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this;} 
private: 
    int x; 
}; 

gì đang xảy ra (và nó là hợp lệ?) Trong hai tùy chọn sau:

tùy chọn 1:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
    delete a; 
} 

phương án 2:

void main() 
{ 
    foo a; 
    a.done(); 
} 

Câu lệnh thứ hai là delete a; khi chọn ion 1 sẽ gây ra một ngoại lệ hoặc tham nhũng đống?

Tùy chọn2 có gây ra ngoại lệ hoặc tham nhũng heap không?

Answer 1

delete this; được phép, nó sẽ xóa đối tượng.

Cả hai đoạn mã của bạn đều có hành vi không xác định - trong trường hợp đầu tiên xóa đối tượng đã bị xóa và trong trường hợp thứ hai xóa đối tượng có thời lượng lưu trữ tự động.

Vì hành vi không được xác định, tiêu chuẩn không cho biết liệu chúng có gây ra ngoại lệ hoặc tham nhũng heap hay không. Đối với các triển khai khác nhau, nó có thể là, không, hoặc cả hai, và nó có thể hoặc có thể không giống nhau mỗi lần bạn chạy mã.

Answer 2

Cả hai đều gây ra lỗi.

Đầu tiên con trỏ bị xóa hai lần, với lỗi thứ hai delete gây ra lỗi.

Answer 3

Cả hai sẽ gây ra lỗi, những gì bạn muốn là:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
} 

nào trình biên dịch sẽ mở rộng tới một cái gì đó như dưới đây, mà tôi hy vọng làm cho xóa "này" một chút ít khó hiểu.

void __foo_done(foo* this) 
{ 
    delete this; 
} 

void main() 
{ 
    foo* a = new foo(); 
    __foo_done(a); 
} 

Xem thêm, Is it legal (and moral) for a member function to say delete this?

Answer 4

Calling delete this là một ý tưởng tồi. Bất cứ ai gọi new nên gọi số delete. Do đó các vấn đề như được nêu bật trong các phản ứng khác.

Ngoài ra, bạn có thể bị rò rỉ bộ nhớ/hành vi không xác định khi tạo một mảng đối tượng.

Answer 5

Trong cả hai trường hợp, heap của bạn sẽ bị hỏng. Tất nhiên, bạn không thể sử dụng trong tùy chọn 2 "->" nếu giá trị bên trái (trong trường hợp này, "a") không phải là một con trỏ, biểu mẫu chính xác trong tùy chọn 2 sẽ là a.done(); Nhưng yeah, bạn sẽ nhận được một đống tham nhũng nếu bạn cố gắng xóa 1) những gì đã bị xóa, hoặc 2) biến địa phương.

Gọi "xóa mục này" về mặt kỹ thuật hợp lệ và giải phóng bộ nhớ.

EDIT Tôi đã tò mò và thực sự cố gắng này:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this; } 
    void test() { x = 2; } 
    int getx() { return x; } 
private: 
    int x; 
} ; 


int main(int argc, char* argv[]) 
{ 
    foo *a = new foo(); 
    a->done(); 
    a->test(); 
    int x = a->getx(); 
    printf("%i\n", x); 
    return x; 
} 

Một cuộc gọi đến printf sẽ thành công, và x sẽ giữ giá trị 2.

Answer 6

Tôi sẽ rất thận trọng về ngữ cảnh trong đó bạn giải phóng bộ nhớ. Trong khi gọi "xóa này"; sẽ cố gắng giải phóng bộ nhớ liên kết với cấu trúc lớp, hoạt động đó không có phương tiện để suy luận ngữ cảnh của việc phân bổ bộ nhớ ban đầu, tức là, nếu nó được cấp phát từ heap hoặc chồng. Lời khuyên của tôi là làm lại mã của bạn để thao tác deallocation được gọi từ một ngữ cảnh bên ngoài. Lưu ý rằng điều này khác với các cấu trúc deallocating bên trong lớp, trong trường hợp đó, sử dụng destructor.

Answer 7

Câu hỏi này đã được trả lời nhưng tôi sẽ bổ sung thêm một điểm mới nếu lớp của bạn thực hiện cuộc gọi này thì bạn cũng nên hủy riêng tư.

Điều này đảm bảo rằng chỉ có lớp có thể tự xóa.

Nếu bạn đặt trình phá hủy của mình ở trên, cả hai mẫu mã của bạn sẽ không thể biên dịch được.