Meneruskan shared_ptr <Derived> sebagai shared_ptr <Base>

Apa metode terbaik untuk meneruskan sebuah shared_ptrdari tipe turunan ke fungsi yang mengambil shared_ptrtipe dasar?

Saya biasanya melewatkan shared_ptrreferensi untuk menghindari salinan yang tidak perlu:

int foo(const shared_ptr<bar>& ptr);

tetapi ini tidak berhasil jika saya mencoba melakukan sesuatu seperti

int foo(const shared_ptr<Base>& ptr);

...

shared_ptr<Derived> bar = make_shared<Derived>();
foo(bar);

Saya bisa menggunakan

foo(dynamic_pointer_cast<Base, Derived>(bar));

tetapi ini tampaknya kurang optimal karena dua alasan:

• A dynamic_casttampaknya agak berlebihan untuk pemeran turunan-ke-dasar sederhana.
• Seperti yang saya pahami, dynamic_pointer_castmembuat salinan (meskipun sementara) dari pointer untuk diteruskan ke fungsi.

Apakah ada solusi yang lebih baik?

Pembaruan untuk anak cucu:

Ternyata itu adalah masalah file header yang hilang. Juga, apa yang saya coba lakukan di sini dianggap sebagai antipattern. Umumnya,

• Fungsi yang tidak mempengaruhi masa pakai objek (yaitu, objek tetap valid selama durasi fungsi) harus menggunakan referensi atau penunjuk biasa, misalnya int foo(bar& b).

• Fungsi yang mengkonsumsi suatu objek (yaitu pengguna akhir dari objek tertentu) harus mengambil unique_ptrnilai, misalnya int foo(unique_ptr<bar> b). Penelepon harus std::movememasukkan nilai ke dalam fungsi.

• Fungsi yang memperpanjang umur suatu objek harus shared_ptrberdasarkan nilai, misalnya int foo(shared_ptr<bar> b). Nasihat biasa untuk menghindari referensi melingkar berlaku.

Lihat pembicaraan Kembali ke Dasar Herb Sutter untuk detailnya.

Meskipun Basedan Derivedyang kovarian dan pointer baku untuk mereka akan bertindak sesuai, shared_ptr<Base>dan shared_ptr<Derived>yang tidak kovarian. Ini dynamic_pointer_castadalah cara yang benar dan paling sederhana untuk menangani masalah ini.

( Edit: static_pointer_cast akan lebih sesuai karena Anda melakukan transmisi dari turunan ke basis, yang aman dan tidak memerlukan pemeriksaan waktu proses. Lihat komentar di bawah.)

Namun, jika foo()fungsi Anda tidak ingin mengambil bagian dalam memperpanjang masa pakai (atau, lebih tepatnya, mengambil bagian dalam kepemilikan bersama objek), sebaiknya terima const Base&dan dereferensi shared_ptrsaat meneruskannya foo().

void foo(const Base& base);
[...]
shared_ptr<Derived> spDerived = getDerived();
foo(*spDerived);

Selain itu, karena shared_ptrtipe tidak bisa menjadi kovarian, aturan konversi implisit di seluruh tipe kembalian kovarian tidak berlaku saat mengembalikan tipe shared_ptr<T>.

Ini juga akan terjadi jika Anda lupa menentukan warisan publik pada kelas turunan, yaitu jika seperti saya Anda menulis ini:

class Derived : Base
{
};

Sepertinya Anda berusaha terlalu keras. shared_ptrmurah untuk disalin; itulah salah satu tujuannya. Mengedarkannya dengan referensi tidak akan menghasilkan banyak hal. Jika Anda tidak ingin berbagi, teruskan penunjuk mentah.

Meskipun demikian, ada dua cara untuk melakukan ini yang dapat saya pikirkan:

foo(shared_ptr<Base>(bar));
foo(static_pointer_cast<Base>(bar));

Periksa juga apakah #includefile header yang berisi deklarasi lengkap kelas turunan ada di file sumber Anda.

Saya punya masalah ini. Itu std::shared<derived>tidak akan dilemparkan ke std::shared<base>. Saya telah mendeklarasikan kedua kelas ke depan sehingga saya dapat menyimpan petunjuk kepada mereka, tetapi karena saya tidak memiliki #includekompilator tidak dapat melihat bahwa satu kelas diturunkan dari yang lain.