CẬP NHẬT
Câu trả lời này khá cũ và mô tả những gì "tốt" vào thời điểm đó, đó là những gợi ý thông minh được cung cấp bởi thư viện Boost. Kể từ C ++ 11, các thư viện chuẩn đã được cung cấp đủ con trỏ thông minh loại, và vì vậy bạn nên ủng hộ việc sử dụng std::unique_ptr, std::shared_ptrvà std::weak_ptr.
Cũng có std::auto_ptr. Nó rất giống với một con trỏ có phạm vi, ngoại trừ việc nó cũng có khả năng nguy hiểm "đặc biệt" được sao chép - điều này cũng bất ngờ chuyển quyền sở hữu.
Nó không được dùng trong C ++ 11 và bị xóa trong C ++ 17 , vì vậy bạn không nên sử dụng nó.
std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership.
// p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.
TRẢ LỜI
Một con trỏ thông minh là một lớp bao bọc một con trỏ C ++ 'thô' (hoặc 'trần'), để quản lý thời gian tồn tại của đối tượng được trỏ tới. Không có loại con trỏ thông minh duy nhất, nhưng tất cả chúng đều cố gắng trừu tượng một con trỏ thô theo cách thực tế.
Con trỏ thông minh nên được ưu tiên hơn con trỏ thô. Nếu bạn cảm thấy cần sử dụng con trỏ (trước tiên hãy xem xét nếu bạn thực sự làm như vậy), thông thường bạn sẽ muốn sử dụng một con trỏ thông minh vì điều này có thể làm giảm bớt nhiều vấn đề với con trỏ thô, chủ yếu là quên xóa đối tượng và rò rỉ bộ nhớ.
Với con trỏ thô, lập trình viên phải tiêu diệt rõ ràng đối tượng khi nó không còn hữu ích.
// Need to create the object to achieve some goal
MyObject* ptr = new MyObject();
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?
Một con trỏ thông minh bằng cách so sánh xác định một chính sách khi đối tượng bị phá hủy. Bạn vẫn phải tạo đối tượng, nhưng bạn không còn phải lo lắng về việc phá hủy nó.
SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.
// Destruction of the object happens, depending
// on the policy the smart pointer class uses.
// Destruction would happen even if DoSomething()
// raises an exception
Chính sách đơn giản nhất được sử dụng liên quan đến phạm vi của đối tượng trình bao bọc con trỏ thông minh, chẳng hạn như được thực hiện bởi boost::scoped_ptrhoặc std::unique_ptr.
void f()
{
{
std::unique_ptr<MyObject> ptr(new MyObject());
ptr->DoSomethingUseful();
} // ptr goes out of scope --
// the MyObject is automatically destroyed.
// ptr->Oops(); // Compile error: "ptr" not defined
// since it is no longer in scope.
}
Lưu ý rằng các std::unique_ptrtrường hợp không thể được sao chép. Điều này ngăn con trỏ bị xóa nhiều lần (không chính xác). Tuy nhiên, bạn có thể chuyển các tham chiếu đến nó xung quanh cho các chức năng khác mà bạn gọi.
std::unique_ptrs rất hữu ích khi bạn muốn gắn thời gian tồn tại của đối tượng với một khối mã cụ thể hoặc nếu bạn nhúng nó dưới dạng dữ liệu thành viên bên trong một đối tượng khác, thời gian tồn tại của đối tượng đó. Đối tượng tồn tại cho đến khi khối mã chứa được thoát ra hoặc cho đến khi chính đối tượng chứa bị phá hủy.
Một chính sách con trỏ thông minh phức tạp hơn liên quan đến việc tham chiếu đếm con trỏ. Điều này không cho phép con trỏ được sao chép. Khi "tham chiếu" cuối cùng đến đối tượng bị hủy, đối tượng sẽ bị xóa. Chính sách này được thực hiện bởi boost::shared_ptrvà std::shared_ptr.
void f()
{
typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
MyObjectPtr p1; // Empty
{
MyObjectPtr p2(new MyObject());
// There is now one "reference" to the created object
p1 = p2; // Copy the pointer.
// There are now two references to the object.
} // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero.
// The object is deleted.
Con trỏ đếm tham chiếu rất hữu ích khi thời gian tồn tại của đối tượng của bạn phức tạp hơn nhiều và không được gắn trực tiếp vào một phần mã cụ thể hoặc đối tượng khác.
Có một nhược điểm đối với con trỏ đếm tham chiếu - khả năng tạo tham chiếu lơ lửng:
// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!
Một khả năng khác là tạo tham chiếu vòng tròn:
struct Owner {
std::shared_ptr<Owner> other;
};
std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1
// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!
Để khắc phục sự cố này, cả Boost và C ++ 11 đều đã xác định a weak_ptrđể xác định tham chiếu yếu (không đếm được) đến a shared_ptr.