Pemusnah C adalah fungsi ahli khas yang dipanggil secara automatik apabila objek keluar dari skop atau dipadam, penting untuk pengurusan sumber. 1) Mereka memastikan sumber dikeluarkan dengan betul, mencegah kebocoran memori. 2) Destructors mengautomasikan pembersihan, mengurangkan kesilapan, dan menjadi kunci kepada RAII. 3) Pemusnah maya adalah penting dalam warisan untuk pembersihan kelas yang diperolehi. 4) Pointer pintar seperti STD :: Shared_ptr membantu menguruskan kebergantungan bulat, mengelakkan masalah seperti pemadaman berganda.

Apabila menyelam ke C, memahami bagaimana untuk menguruskan memori dan sumber daya dengan cekap adalah penting. Satu konsep utama yang akan anda hadapi awal adalah pemusnah . Jadi, apa sebenarnya pemusnah C, dan mengapa pemula perlu mengambil berat tentang mereka?

Pemusnah C adalah fungsi ahli khas yang secara automatik dipanggil apabila objek kelas keluar dari skop atau secara eksplisit dipadam. Mereka memainkan peranan penting dalam pengurusan sumber, memastikan bahawa mana -mana sumber yang diperuntukkan oleh objek itu dikeluarkan dengan betul. Fikirkan mereka sebagai krew pembersihan untuk objek anda.

Mari kita menyelam lebih mendalam ke dalam topik yang menarik ini. Bayangkan anda sedang membina sebuah rumah di c -destructors adalah seperti pasukan perobohan yang masuk selepas anda selesai, memastikan segala -galanya dibongkar dan dibersihkan dengan betul.

Pada hari -hari awal pengekodan saya, saya sering mengabaikan kepentingan pemusnah, yang membawa kepada kebocoran ingatan dan pembaziran sumber. Belajar tentang mereka membuka mata saya untuk keanggunan pengurusan sumber C. Sekarang, mari kita meneroka konsep ini lebih lanjut, berkongsi beberapa pandangan dan contoh kod yang telah membantu saya dan banyak lagi.

Apabila anda membuat objek di C, anda mungkin memperuntukkan memori atau sumber lain. Sebagai contoh, jika anda mempunyai kelas yang menguruskan fail, anda perlu membuka fail itu apabila objek dibuat. Tetapi apa yang berlaku apabila objek tidak lagi diperlukan? Di sinilah pemusnah melangkah masuk.

Inilah contoh mudah untuk menggambarkan:

 #include <iostream>
#include <string>

Kelas FileHandler {
Swasta:
    std :: rentetan nama fail;
    Fail* fail;

awam:
    // Pembina
    FileHandler (const std :: string & name): filename (name), file (nullptr) {
        file = fopen (fileName.c_str (), "r");
        jika (file == nullptr) {
            std :: Cerr << "Fail Pembukaan Ralat:" << FileName << std :: endl;
        } else {
            std :: cout << "Fail dibuka:" << filename << std :: endl;
        }
    }

    // Destructor
    ~ FileHandler () {
        jika (file! = nullptr) {
            fclose (fail);
            std :: cout << "Fail ditutup:" << filename << std :: endl;
        }
    }
};

int main () {
    FileHandler fh ("example.txt");
    // Gunakan fail ...
    kembali 0;
}

Dalam contoh ini, apabila fh keluar dari skop pada akhir main() , destructor ~FileHandler() secara automatik dipanggil, memastikan fail ditutup dengan betul.

Memahami pemusnah bukan hanya tentang menulis kod bersih; Ini mengenai menguasai seni pengurusan sumber dalam c. Berikut adalah beberapa pandangan dan petua yang saya kumpulkan selama bertahun -tahun:

• Automatik vs Pembersihan Manual : Destructors mengautomasikan proses pembersihan, mengurangkan kemungkinan kesilapan manusia. Walau bagaimanapun, adalah penting untuk memastikan semua sumber diuruskan dengan betul dalam pemusnah.
• RAII (pengambilalihan sumber adalah inisialisasi) : Idiom C 'S RAII sangat bergantung pada pemusnah. Dengan mengikat pengurusan sumber untuk membantah seumur hidup, anda memastikan bahawa sumber -sumber dikeluarkan walaupun pengecualian berlaku.
• Pemusnah maya : Jika anda bekerja dengan warisan, selalu membuat pemusnah kelas asas maya untuk memastikan pemusnah kelas yang diperolehi dipanggil dengan betul.

Berikut adalah contoh pemusnah maya dalam tindakan:

 #include <iostream>

asas kelas {
awam:
    maya ~ asas () {
        std :: cout << "Destructor asas yang dipanggil" << std :: endl;
    }
};

kelas yang diperolehi: asas awam {
awam:
    ~ Berasal () mengatasi {
        std :: cout << "Pemusnah yang diperolehi yang dipanggil" << std :: endl;
    }
};

int main () {
    Asas* b = baru diperoleh ();
    padam b; // Ini akan memanggil pemusnah yang diturunkan terlebih dahulu, kemudian Base
    kembali 0;
}

Dalam kes ini, apabila delete b dipanggil, urutan yang betul panggilan Destructor memastikan pembersihan sumber kelas yang diperolehi.

Semasa anda menyelidiki lebih jauh ke C, anda akan menghadapi senario di mana pemusnah boleh menjadi rumit. Sebagai contoh, pertimbangkan kes kebergantungan bulat, di mana dua objek merujuk antara satu sama lain. Tanpa reka bentuk pemusnah yang berhati -hati, anda mungkin berakhir dengan kebocoran memori atau bebas dua. Inilah contoh mudah untuk menggambarkan masalahnya:

 #include <iostream>

Kelas A {
awam:
    A (): b (nullptr) {}
    ~ A () {
        std :: cout << "Destructor yang dipanggil" << std :: endl;
        padam b;
    }
    void setb (kelas b* newb) {b = newb; }

Swasta:
    Kelas B* B;
};

Kelas B {
awam:
    B (): a (nullptr) {}
    ~ B () {
        std :: cout << "b destructor yang dipanggil" << std :: endl;
        padam a;
    }
    void seta (a* newa) {a = newa; }

Swasta:
    A* a;
};

int main () {
    A* a = new a ();
    B* b = new b ();
    a-> setb (b);
    b-> seta (a);
    padam a; // ini akan menyebabkan padam ganda
    kembali 0;
}

Dalam contoh ini, memadam a Leads to a Double Delete of b , menyebabkan tingkah laku yang tidak ditentukan. Untuk mengelakkan isu -isu tersebut, anda boleh menggunakan penunjuk pintar seperti std::shared_ptr atau std::unique_ptr , yang menguruskan hayat objek secara automatik dan mencegah perangkap tersebut.

Berikut adalah cara anda boleh refactor contoh sebelumnya menggunakan std::shared_ptr :

 #include <iostream>
#include <sory>

Kelas A;
Kelas B;

Kelas A {
awam:
    A () {}
    ~ A () {
        std :: cout << "Destructor yang dipanggil" << std :: endl;
    }
    void setB (std :: shared_ptr <b> newb) {b = newb; }

Swasta:
    std :: shared_ptr <b> b;
};

Kelas B {
awam:
    B () {}
    ~ B () {
        std :: cout << "b destructor yang dipanggil" << std :: endl;
    }
    void seta (std :: shared_ptr <a> newa) {a = newa; }

Swasta:
    std :: shared_ptr <a> a;
};

int main () {
    auto a = std :: make_shared <a> ();
    auto b = std :: make_shared <b> ();
    a-> setb (b);
    b-> seta (a);
    // Tidak perlu memadam secara manual A atau B; mereka akan diuruskan secara automatik
    kembali 0;
}

Menggunakan std::shared_ptr memastikan bahawa objek dibersihkan dengan betul apabila mereka tidak lagi dirujuk, mengelakkan isu padam ganda.

Kesimpulannya, pemusnah adalah aspek asas C yang harus difahami oleh setiap pemula. Mereka bukan hanya untuk membersihkan; Mereka merangkumi falsafah pengurusan sumber yang cekap dalam c. Dengan menguasai pemusnah, anda akan menulis lebih banyak kod yang kukuh, cekap, dan lebih selamat. Ingat, perjalanan pembelajaran C dipenuhi dengan permata seperti itu -merangkul mereka, dan anda akan mendapati bahasa lebih bermanfaat daripada sebelumnya.

Atas ialah kandungan terperinci Apakah pemusnah C? Dijelaskan untuk pemula. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!