Meneruskan petunjuk bersama sebagai argumen

Jika saya mendeklarasikan objek yang dibungkus dengan pointer bersama:

std::shared_ptr<myClass> myClassObject(new myClass());

maka saya ingin menyampaikannya sebagai argumen untuk suatu metode:

DoSomething(myClassObject);

//the called method
void DoSomething(std::shared_ptr<myClass> arg1)
{
   arg1->someField = 4;
}

Apakah hal di atas hanya menambah jumlah referensi shared_pt dan semuanya keren? Atau apakah itu meninggalkan penunjuk yang menggantung?

Apakah Anda masih harus melakukan ini ?:

DoSomething(myClassObject.Get());

void DoSomething(std::shared_ptr<myClass>* arg1)
{
   (*arg1)->someField = 4;
}

Saya pikir cara ke-2 mungkin lebih efisien karena hanya harus menyalin 1 alamat (sebagai lawan dari seluruh penunjuk cerdas), tetapi cara pertama tampaknya lebih mudah dibaca dan saya tidak mengantisipasi mendorong batas kinerja. Saya hanya ingin memastikan tidak ada yang berbahaya tentang itu.

Terima kasih.

Saya ingin meneruskan penunjuk bersama ke suatu fungsi. Bisakah Anda membantu saya dengan itu?

Tentu, saya bisa bantu soal itu. Saya berasumsi Anda memiliki pemahaman tentang semantik kepemilikan di C ++. Benarkah itu?

Ya, saya cukup nyaman dengan subjek ini.

Baik.

Oke, saya hanya bisa memikirkan dua alasan untuk shared_ptrberargumen:

1. Fungsi ingin berbagi kepemilikan objek;
2. Fungsi ini melakukan beberapa operasi yang bekerja secara spesifik pada shared_ptrs.

Yang mana yang Anda minati?

Saya mencari jawaban umum, jadi saya sebenarnya tertarik pada keduanya. Saya ingin tahu tentang apa yang Anda maksud dalam kasus # 2.

Contoh dari fungsi tersebut termasuk std::static_pointer_cast, pembanding kustom, atau predikat. Misalnya, jika Anda perlu menemukan semua shared_ptr unik dari vektor, Anda memerlukan predikat seperti itu.

Ah, ketika fungsinya benar-benar perlu memanipulasi smart pointer itu sendiri.

Persis.

Dalam hal ini, saya pikir kita harus melewati referensi.

Iya. Dan jika itu tidak mengubah penunjuk, Anda ingin melewati referensi const. Tidak perlu menyalin karena Anda tidak perlu berbagi kepemilikan. Itu skenario lainnya.

OK mengerti. Mari kita bicara tentang skenario lainnya.

Di mana Anda berbagi kepemilikan? Baik. Bagaimana Anda berbagi kepemilikan dengan shared_ptr?

Dengan menyalinnya.

Maka fungsi tersebut perlu membuat salinan dari a shared_ptr, benar?

Jelas sekali. Jadi saya meneruskannya dengan referensi ke const dan menyalin ke variabel lokal?

Tidak, itu pesimisasi. Jika diteruskan oleh referensi, fungsi tidak punya pilihan selain membuat salinan secara manual. Jika itu dilewatkan oleh nilai kompilator akan memilih pilihan terbaik antara salinan dan pemindahan dan melakukannya secara otomatis. Jadi, lewati nilai.

Poin yang bagus. Saya harus lebih sering mengingat artikel " Want Speed? Pass by Value ".

Tunggu, bagaimana jika fungsi tersebut menyimpan shared_ptrdalam variabel anggota, misalnya? Bukankah itu akan membuat salinan yang berlebihan?

Fungsi tersebut dapat dengan mudah memindahkan shared_ptrargumen ke penyimpanannya. Memindahkan shared_ptrmurah karena tidak mengubah jumlah referensi apa pun.

Ah, ide bagus.

Tetapi saya memikirkan skenario ketiga: bagaimana jika Anda tidak ingin memanipulasi shared_ptr, atau berbagi kepemilikan?

Dalam hal ini, shared_ptrsama sekali tidak relevan dengan fungsinya. Jika Anda ingin memanipulasi orang yang ditunjuk, ambil orang yang ditunjuk, dan biarkan penelepon memilih semantik kepemilikan yang mereka inginkan.

Dan haruskah saya mengambil poin tersebut dengan referensi atau nilai?

Aturan biasa berlaku. Petunjuk cerdas tidak mengubah apa pun.

Lewati nilai jika saya akan menyalin, meneruskan referensi jika saya ingin menghindari salinan.

Baik.

Hmm. Saya pikir Anda lupa skenario lain. Bagaimana jika saya ingin berbagi kepemilikan, tetapi hanya bergantung pada kondisi tertentu?

Ah, kasus tepi yang menarik. Saya tidak berharap itu sering terjadi. Tetapi ketika itu terjadi, Anda dapat meneruskan nilai dan mengabaikan salinannya jika Anda tidak membutuhkannya, atau meneruskan referensi dan membuat salinannya jika Anda membutuhkannya.

Saya mengambil risiko satu salinan yang berlebihan di opsi pertama, dan kehilangan potensi perpindahan di opsi kedua. Tidak bisakah saya makan kue dan memakannya juga?

Jika Anda berada dalam situasi di mana itu benar-benar penting, Anda dapat memberikan dua kelebihan, satu mengambil referensi nilai konstanta, dan yang lainnya mengambil referensi nilai r. Satu salinan, yang lainnya bergerak. Templat fungsi penerusan sempurna adalah opsi lain.

Saya pikir itu mencakup semua kemungkinan skenario. Terima kasih banyak.

Saya pikir orang tidak perlu takut menggunakan pointer mentah sebagai parameter fungsi. Jika fungsi tidak akan menyimpan penunjuk atau mempengaruhi masa pakainya, penunjuk mentah bekerja dengan baik dan mewakili penyebut terkecil yang sama. Pertimbangkan misalnya bagaimana Anda akan meneruskan a unique_ptrke dalam fungsi yang mengambil a shared_ptrsebagai parameter, baik dengan nilai atau referensi const?

void DoSomething(myClass * p);

DoSomething(myClass_shared_ptr.get());
DoSomething(myClass_unique_ptr.get());

Pointer mentah sebagai parameter fungsi tidak mencegah Anda menggunakan smart pointer dalam kode panggilan, yang sangat penting.

Ya, keseluruhan ide tentang shared_ptr <> adalah bahwa beberapa instance dapat menampung pointer mentah yang sama dan memori yang mendasarinya hanya akan dibebaskan ketika instance terakhir shared_ptr <> dihancurkan.

Saya akan menghindari pointer ke shared_ptr <> karena itu mengalahkan tujuan karena Anda sekarang berurusan dengan raw_pointers lagi.

Nilai lewat dalam contoh pertama Anda aman, tetapi ada idiom yang lebih baik. Lewati referensi const bila memungkinkan - saya akan mengatakan ya bahkan ketika berhadapan dengan petunjuk cerdas. Contoh kedua Anda tidak benar-benar rusak tetapi sangat !???. Konyol, tidak mencapai apa-apa dan mengalahkan sebagian dari inti dari petunjuk cerdas, dan akan meninggalkan Anda dalam dunia kesakitan saat Anda mencoba untuk membedakan dan memodifikasi sesuatu.

dalam fungsi DoSomething Anda, Anda mengubah anggota data dari sebuah instance kelas myClass jadi apa yang Anda ubah adalah objek yang dikelola (pointer mentah) bukan objek (shared_ptr). Yang berarti pada titik balik fungsi ini semua pointer yang dibagikan ke pointer mentah terkelola akan melihat anggota datanya: myClass::someFielddiubah ke nilai yang berbeda.

dalam hal ini, Anda meneruskan objek ke fungsi dengan jaminan bahwa Anda tidak mengubahnya (berbicara tentang shared_ptr, bukan objek yang dimiliki).

Ungkapan untuk mengungkapkan ini adalah melalui: ref const, seperti itu

void DoSomething(const std::shared_ptr<myClass>& arg)

Demikian pula Anda memastikan pengguna fungsi Anda, bahwa Anda tidak menambahkan pemilik lain ke daftar pemilik penunjuk mentah. Namun, Anda tetap memiliki kemungkinan untuk mengubah objek pokok yang ditunjukkan oleh penunjuk mentah.

CAVEAT: Artinya, jika seseorang memanggil shared_ptr::resetsebelum Anda memanggil fungsi Anda, dan pada saat itu adalah shared_ptr terakhir yang memiliki raw_ptr, maka objek Anda akan dimusnahkan, dan fungsi Anda akan memanipulasi Pointer yang menggantung ke objek yang dihancurkan. SANGAT BERBAHAYA!!!