UPDATE
คำตอบนี้ค่อนข้างเก่าและอธิบายสิ่งที่ 'ดี' ในเวลานั้นซึ่งเป็นตัวชี้สมาร์ทที่ได้รับจากห้องสมุด Boost ตั้งแต่ C ++ 11, ไลบรารีมาตรฐานได้จัดเตรียมพอยน์เตอร์พอยน์เตอร์ให้เพียงพอ, ดังนั้นคุณควรใช้และstd::unique_ptr, .std::shared_ptrstd::weak_ptr
std::auto_ptrนอกจากนี้ยังมี มันเป็นเหมือนตัวชี้ที่กำหนดขอบเขตยกเว้นว่ามันมีความสามารถที่เป็นอันตราย "พิเศษ" ที่จะคัดลอกซึ่งยังโอนความเป็นเจ้าของโดยไม่คาดคิด
มันเลิกใช้แล้วใน C ++ 11 และนำออกใน C ++ 17ดังนั้นคุณไม่ควรใช้
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.
คำตอบเดิม ๆ
ตัวชี้สมาร์ทเป็นคลาสที่ล้อมรอบตัวชี้ C ++ แบบ 'ดิบ' (หรือ 'เปล่า') เพื่อจัดการอายุการใช้งานของวัตถุที่ถูกชี้ไป ไม่มีประเภทตัวชี้สมาร์ทเดียว แต่พวกเขาทั้งหมดพยายามที่จะทำให้ตัวชี้แบบดิบ ๆ เป็นจริงในทางปฏิบัติ
ตัวชี้สมาร์ทควรเป็นที่ต้องการมากกว่าตัวชี้แบบดิบ ถ้าคุณรู้สึกว่าคุณต้องใช้พอยน์เตอร์ (ก่อนอื่นให้พิจารณาถ้าคุณทำจริงๆ ) โดยปกติแล้วคุณต้องการใช้พอยน์เตอร์สมาร์ทเพราะมันจะช่วยบรรเทาปัญหามากมายที่เกิดขึ้นกับพอยน์เตอร์พอยน์เตอร์
ด้วยตัวชี้แบบดิบโปรแกรมเมอร์ต้องทำลายวัตถุอย่างชัดเจนเมื่อไม่มีประโยชน์อีกต่อไป
// 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...?
ตัวชี้สมาร์ทโดยการเปรียบเทียบกำหนดนโยบายว่าเมื่อวัตถุถูกทำลาย คุณยังต้องสร้างวัตถุ แต่คุณไม่ต้องกังวลกับการทำลายมันอีกต่อไป
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
นโยบายที่ง่ายในการใช้งานที่เกี่ยวข้องกับขอบเขตของวัตถุชี้เสื้อคลุมสมาร์ทเช่นดำเนินการโดยหรือboost::scoped_ptrstd::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.
}
โปรดทราบว่าstd::unique_ptrไม่สามารถคัดลอกอินสแตนซ์ได้ สิ่งนี้ป้องกันไม่ให้ตัวชี้ถูกลบหลายครั้ง (ไม่ถูกต้อง) อย่างไรก็ตามคุณสามารถส่งต่อการอ้างอิงไปยังฟังก์ชันอื่นที่คุณโทรได้
std::unique_ptrs มีประโยชน์เมื่อคุณต้องการผูกอายุการใช้งานของวัตถุกับบล็อกของรหัสเฉพาะหรือถ้าคุณฝังเป็นข้อมูลสมาชิกภายในวัตถุอื่นอายุการใช้งานของวัตถุอื่น มีวัตถุอยู่จนกระทั่งบล็อกที่มีรหัสถูกออกหรือจนกว่าวัตถุที่บรรจุนั้นจะถูกทำลาย
นโยบายตัวชี้สมาร์ทที่ซับซ้อนยิ่งขึ้นเกี่ยวข้องกับการนับการอ้างอิงตัวชี้ นี่เป็นการอนุญาตให้ตัวชี้ถูกคัดลอก เมื่อ "การอ้างอิง" สุดท้ายไปยังวัตถุถูกทำลายวัตถุจะถูกลบ นโยบายนี้จะดำเนินการโดยและboost::shared_ptrstd::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.
พอยน์เตอร์ที่นับตามการอ้างอิงนั้นมีประโยชน์มากเมื่ออายุการใช้งานของวัตถุของคุณซับซ้อนกว่ามากและไม่ได้เชื่อมโยงโดยตรงกับส่วนใดส่วนหนึ่งของรหัสหรือวัตถุอื่น
มีหนึ่งอุปสรรคในการอ้างอิงพอยน์เตอร์นับ - ความเป็นไปได้ของการสร้างการอ้างอิงห้อย:
// 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!
ความเป็นไปได้อีกอย่างก็คือการสร้างการอ้างอิงแบบวงกลม:
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!
เมื่อต้องการแก้ไขปัญหานี้ทั้ง Boost และ C ++ 11 ได้กำหนดweak_ptrที่จะกำหนดอ่อนแอ (ไม่ได้นับ) shared_ptrอ้างอิงถึง