Bagaimanakah pemusnahan pintar dan keselamatan pengecualian dilaksanakan dalam petunjuk pintar C++?

Jawapan: Pemusnahan pintar dan pelaksanaan selamat pengecualian: Penunjuk pintar menggunakan pemusnah yang diganti untuk menyokong panggilan automatik pemusnah selepas objek yang ditunjuk oleh penuding terkeluar dari skop. Mereka menggunakan kelas jaminan pengecualian untuk memastikan bahawa pemusnah sentiasa dipanggil apabila pengecualian berlaku untuk memastikan objek dilepaskan dengan betul. Pemusnahan pintar: Gantikan operator pemusnah (~) untuk melepaskan objek secara automatik apabila ia keluar dari skop. Keselamatan pengecualian: Gunakan kelas perlindungan pengecualian untuk memastikan bahawa pemusnah sentiasa dipanggil apabila pengecualian berlaku. Kes praktikal: uruskan objek yang diperuntukkan secara dinamik untuk mengelakkan kebocoran memori dan permudahkan kod

Pemusnahan pintar dan pelaksanaan keselamatan pengecualian dalam petunjuk pintar C++

Pengenalan

Satu penunjuk gabungan pintar mereka ialah kaedah gabungan penunjuk pintar. seumur hidup dan mekanisme pelepasan yang menggabungkan ciri bahasa C++. Mereka memberikan kelebihan berikut:

• Pengurusan memori automatik
• Keselamatan pengecualian
• Pemusnahan pintar

Artikel ini akan menumpukan pada mekanisme pelaksanaan pemusnahan pintar dan keselamatan pengecualian dalam penunjuk pintar.

Smart destructor

Smart pointer menyokong secara automatik memanggil pemusnah selepas objek yang ditunjuk oleh penunjuk terkeluar dari skop. Ini dicapai dengan mengatasi operator ~ (destructor). Dalam contoh berikut, UniquePtr secara automatik melepaskan objek yang diurusnya apabila ia keluar dari skop: ~（析构函数）运算符来实现。在下例中，UniquePtr 在超出作用域后自动释放其管理的对象：

#include <memory>

int main() {
  std::unique_ptr<int> ptr(new int(5));
}

智能指针使用析构函数指针跟踪所管理的对象，并在超出作用域时调用该指针以释放对象。

异常安全

智能指针通过异常安全机制确保在异常发生时释放指向对象。这通过使用一组称为 异常保障 的类来实现。这些类负责确保在异常发生时始终调用析构函数，即使发生了异常。

例如，std::shared_ptr

#include <memory>

int main() {
  try {
    std::shared_ptr<int> ptr = std::make_shared<int>(5);
    throw std::runtime_error("异常已抛出");
  } catch (...) {
    // 指针 ptr 已在异常抛出时释放
  }
}

Penunjuk pintar menggunakan penuding pemusnah untuk menjejaki objek yang diurusnya dan memanggil penuding itu apabila ia keluar dari skop.

Keselamatan pengecualian

Penunjuk pintar menggunakan mekanisme keselamatan pengecualian untuk memastikan objek runcing dilepaskan apabila pengecualian berlaku. Ini dicapai menggunakan satu set kelas yang dipanggil jaminan pengecualian. Kelas ini bertanggungjawab untuk memastikan bahawa pemusnah sentiasa dipanggil apabila pengecualian berlaku, walaupun pengecualian berlaku.

• Sebagai contoh, std::shared_ptr menggunakan jaminan pengecualian untuk penunjuk kepada objek pemilikan dikongsi. Ia memastikan bahawa apabila pengecualian dilemparkan dan melonggarkan tindanan dibatalkan, kiraan pemilikan dikurangkan dengan betul dan objek dilepaskan dengan betul:

#include <memory>

class MyClass {
public:
  MyClass() { std::cout << "构造 MyClass" << std::endl; }
  ~MyClass() { std::cout << "析构 MyClass" << std::endl; }
};

int main() {
  std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
}

• Contoh praktikal

Petunjuk pintar berguna dalam banyak senario, termasuk:

Mengurus objek yang diperuntukkan secara dinamik

Cegah kebocoran memori

Ringkaskan kod🎜🎜🎜Berikut ialah contoh yang menunjukkan cara menggunakan penunjuk pintar untuk mengurus objek yang diperuntukkan secara dinamik: 🎜

构造 MyClass
析构 MyClass

🎜Menjalankan kod ini akan menghasilkan output berikut: objek telah dimulakan dengan betul dan dibebaskan. 🎜

Atas ialah kandungan terperinci Bagaimanakah pemusnahan pintar dan keselamatan pengecualian dilaksanakan dalam petunjuk pintar C++?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!