MEMPERBARUI
Jawaban ini agak lama, dan karenanya menggambarkan apa yang 'baik' pada saat itu, yang merupakan petunjuk cerdas yang disediakan oleh perpustakaan Boost. Sejak C ++ 11, perpustakaan standar telah menyediakan tipe smart pointer yang memadai, dan karenanya Anda harus mendukung penggunaan std::unique_ptr, std::shared_ptrdan std::weak_ptr.
Ada juga std::auto_ptr. Itu sangat mirip dengan penunjuk cakupan, kecuali bahwa ia juga memiliki kemampuan berbahaya "khusus" untuk disalin - yang juga secara tak terduga mengalihkan kepemilikan.
Itu sudah ditinggalkan di C ++ 11 dan dihapus di C ++ 17 , jadi Anda tidak harus menggunakannya.
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.
JAWABAN TUA
Pointer pintar adalah kelas yang membungkus pointer C ++ 'mentah' (atau 'telanjang'), untuk mengatur masa pakai objek yang ditunjuk. Tidak ada satu pun tipe smart pointer, tetapi semuanya mencoba untuk abstrak sebuah pointer mentah dengan cara yang praktis.
Pointer pintar harus lebih disukai daripada pointer mentah. Jika Anda merasa perlu menggunakan pointer (pertimbangkan terlebih dahulu jika benar - benar melakukannya), Anda biasanya ingin menggunakan pointer pintar karena ini dapat meringankan banyak masalah dengan pointer mentah, terutama lupa untuk menghapus objek dan memori yang bocor.
Dengan pointer mentah, programmer harus secara eksplisit menghancurkan objek ketika tidak lagi berguna.
// 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...?
Pointer pintar dengan perbandingan mendefinisikan kebijakan kapan objek dihancurkan. Anda masih harus membuat objek, tetapi Anda tidak perlu lagi khawatir untuk menghancurkannya.
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
Kebijakan paling sederhana yang digunakan melibatkan ruang lingkup objek pembungkus penunjuk pintar, seperti yang diterapkan oleh boost::scoped_ptratau 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.
}
Perhatikan bahwa std::unique_ptrinstance tidak dapat disalin. Ini mencegah penunjuk dihapus beberapa kali (salah). Namun, Anda dapat meneruskan referensi ke fungsi lain yang Anda panggil.
std::unique_ptrs berguna ketika Anda ingin mengikat masa pakai objek ke blok kode tertentu, atau jika Anda menyematkannya sebagai data anggota di dalam objek lain, masa pakai objek lain itu. Objek ada sampai blok kode yang berisi keluar, atau sampai objek yang berisi itu sendiri dihancurkan.
Kebijakan smart pointer yang lebih kompleks melibatkan referensi penghitungan pointer. Ini memungkinkan pointer untuk disalin. Ketika "referensi" terakhir ke objek dihancurkan, objek tersebut dihapus. Kebijakan ini diterapkan oleh boost::shared_ptrdan 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.
Referensi penghitung referensi sangat berguna ketika masa pakai objek Anda jauh lebih rumit, dan tidak terikat langsung ke bagian kode tertentu atau ke objek lain.
Ada satu kelemahan dari referensi penghitung referensi - kemungkinan membuat referensi yang menggantung:
// 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!
Kemungkinan lain adalah membuat referensi melingkar:
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!
Untuk mengatasi masalah ini, Boost dan C ++ 11 telah mendefinisikan a weak_ptruntuk mendefinisikan referensi lemah (tidak terhitung) ke a shared_ptr.