C++, ngăn chặn cá thể lớp được tạo trên ngăn xếp (trong quá trình biên dịch)

Question

Tôi biết có các phương pháp để ngăn không cho lớp được tạo trên heap, bằng cách ngăn người dùng sử dụng toán tử new và delete. Tôi đang cố gắng làm điều ngược lại. Tôi có một lớp mà tôi muốn ngăn chặn người dùng tạo một thể hiện của nó trên ngăn xếp, và chỉ các trường hợp được xúi giục bằng toán tử new sẽ biên dịch. Cụ thể hơn, tôi muốn đoạn mã sau để nhận được một lỗi trong quá trình biên soạn:

MyClass c1; //compilation error 

MyClass* c1 = new MyClass(); //compiles okay 

Từ tìm kiếm trên web, tôi thấy đề nghị này về làm thế nào để làm điều đó:

class MyClass { 
public: 
    MyClass(); 
private: 
    void destroy() const { delete this; } 

... 

private: 
    ~MyClass(); 
}; 

int main(int argc,char** argv) 
{ 
    MyClass myclass; // <--- error, private destructor called here !!! 

    MyClass* myclass_ptr = new MyClass; 
    myclass_ptr->destroy(); 
} 

Những gì tôi không hiểu là lý do tại sao điều này sẽ hoạt động. Tại sao destructor được gọi trong khi tạo một thể hiện của MyClass?

Answer 1

Khi myclass kết thúc phạm vi của nó (} tiếp theo) trình biên dịch gọi hàm hủy để giải phóng nó khỏi ngăn xếp. Tuy nhiên, nếu destructor là private, thì destructor không thể được truy cập, vì vậy lớp không thể được đặt trên stack.

Tôi không thích giao diện của delete this. Nói chung tôi nghĩ rằng các đồ vật không nên tự hủy diệt. Có lẽ cách tốt hơn là có một hàm tạo riêng là cho lớp của bạn, sau đó sử dụng hàm tĩnh để tạo một cá thể.

// In class declaration... 
static MyClass* Create() 
{ 
    return new MyClass(); // can access private constructor 
} 

// ... 

MyClass myclass; // illegal, cannot access private constructor 

MyClass* pMyClass = MyClass::Create(); 
delete pMyClass; // after usage 

Answer 2

Tại sao trình hủy được gọi trong khi tạo một phiên bản MyClass?

Nó không phải. Nó phải được gọi tự động khi cá thể đó đi ra ngoài phạm vi. Nếu nó là riêng tư, trình biên dịch không được tạo ra mã đó, do đó có lỗi.

Nếu bạn nghĩ rằng làm cho tin destructor là tối nghĩa, một cách khác để hạn chế một lớp phân bổ động là làm cho tất cả các nhà thầu tư nhân và chỉ có MyClass::create() chức năng trở về đối tượng được cấp phát động:

class MyClass { 
public: 
    static MyClass* create()    {return new MyClass();} 
    static MyClass* create(const Foo& f) {return new MyClass(f);} 
private: 
    MyClass(); 
    MyClass(const Foo&); 
}; 

Lưu ý rằng trở về con trỏ khỏa thân với các đối tượng cần xóa sẽ bị cau mày. Thay vào đó, bạn nên trả lại con trỏ thông minh:

class MyClass { 
public: 
    static std::shared_ptr<MyClass> create()    {return new MyClass();} 
    static std::shared_ptr<MyClass> create(const Foo& f) {return new MyClass(f);} 
    // ... 
}; 

Answer 3

Vì khi trường hợp vượt quá phạm vi, nó phải bị hủy bằng cách sử dụng hàm hủy. Con trỏ ví dụ không làm điều này.

Answer 4

Bất cứ khi nào biến cục bộ nằm ngoài phạm vi, biến đó sẽ bị hủy. Và trên sự hủy diệt, phá hủy đối tượng được gọi. Ở đây, phạm vi là chức năng chính. Khi thoát chương trình, destructor của đối tượng myclass sẽ được gọi là

Answer 5

Nó không phải. Trình biên dịch đang cố gắng gọi hàm hủy khi nó nằm ngoài phạm vi và chỉ ra dòng mã tạo ra hiệu ứng này, điều này hữu ích hơn nhiều so với việc trỏ vào cuối hàm.