Adakah `std::make_shared` Lebih Cekap Daripada Membina Terus `std::shared_ptr`?

Kecekapan std::make_shared

Semasa mereka bentuk penuding kongsi daripada penuding mentah menggunakan fungsi std::make_shared, terdapat perbezaan dalam kecekapan jika dibandingkan dengan mencipta std::shared_ptr secara langsung menggunakan pembina. Berikut ialah penjelasan langkah demi langkah:

std::make_shared:

1. Peruntukkan memori untuk kedua-dua blok kawalan (yang menguruskan pengiraan rujukan dan metadata lain ) dan objek.
2. Bina objek std::shared_ptr dengan yang diperuntukkan memori.

Direct std::shared_ptr Constructor:

1. Alokasikan memori untuk objek menggunakan baharu.
2. Alokasikan memori untuk blok kawalan.
3. Bina objek std::shared_ptr dengan memori yang diperuntukkan.

Seperti yang anda lihat, std::make_shared melaksanakan satu peruntukan (untuk kedua-dua blok kawalan dan objek), manakala kaedah pembina langsung melaksanakan dua peruntukan (satu untuk objek, satu lagi untuk blok kawalan). Perbezaan dalam peruntukan ini membawa kepada kecekapan yang lebih besar apabila menggunakan std::make_shared.

Exception-Safety

Sebelum C 17, menggunakan std::make_shared juga lebih terkecuali- selamat. Pertimbangkan kod berikut:

void f(const std::shared_ptr<Object1>& obj1, const std::shared_ptr<Object2>& obj2) {
  // ...
}

int main() {
  f(std::shared_ptr<Object1>(new Object1()), std::shared_ptr<Object2>(new Object2()));
  return 0;
}

Tanpa std::make_shared, susunan penilaian argumen tidak ditentukan dan jika peruntukan Object1 gagal, memori untuk Object2 akan bocor. Dengan std::make_shared, isu keselamatan pengecualian ini ditangani.

Kelemahan std::make_shared

Satu potensi kelemahan std::make_shared ialah ia boleh mengelakkan deallokasi awal memori objek. Tidak seperti kaedah pembina langsung, std::make_shared mencipta blok memori tunggal untuk blok kawalan dan objek. Ini bermakna bahawa memori untuk kedua-dua objek dan blok kawalan tidak boleh diagihkan secara bebas. Jika terdapat penunjuk lemah yang menghala ke objek, mereka boleh memastikan blok kawalan hidup walaupun selepas objek itu sendiri tidak lagi digunakan, yang berpotensi membawa kepada pengekalan memori.

Atas ialah kandungan terperinci Adakah `std::make_shared` Lebih Cekap Daripada Membina Terus `std::shared_ptr`?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!