D Destructors adalah fungsi ahli khas yang secara automatik melepaskan sumber apabila objek keluar dari skop atau dipadam. 1) Mereka adalah penting untuk menguruskan memori, pemegang fail, dan sambungan rangkaian. 2) Pemula sering mengabaikan definisi pemusnah untuk memori dinamik, yang membawa kepada kebocoran ingatan. 3) Berlebihan boleh menyebabkan overhead prestasi. 4) Peraturan tiga/lima/sifar harus dipertimbangkan apabila menentukan pemusnah untuk memastikan pengurusan sumber yang betul. 5) Dalam hierarki warisan, pemusnah kelas yang diperolehi dipanggil sebelum pemusnah kelas asas, yang penting untuk pembebasan sumber yang betul.

Apabila ia datang kepada pemusnah C, memahami peranan dan pelaksanaan mereka dapat meningkatkan keupayaan anda untuk menguruskan sumber dengan berkesan. Saya telah melihat senario yang tidak terkira banyaknya di mana pemusnah yang dilaksanakan dengan baik dapat mencegah kebocoran memori dan memastikan pembersihan yang tepat, terutama dalam projek-projek yang kompleks. Mari kita menyelam dunia pemusnah dengan beberapa contoh kod praktikal, dan saya akan berkongsi beberapa pandangan dan perangkap yang berpotensi di sepanjang jalan.

D Destructors adalah fungsi ahli khas yang dapat dipanggil secara automatik apabila objek kelas keluar dari skop atau secara eksplisit dipadamkan. Mereka sangat penting untuk melepaskan sumber seperti memori, pemegang fail, atau sambungan rangkaian. Dari pengalaman saya, pemula kesilapan biasa membuat mengabaikan untuk menentukan pemusnah apabila menguruskan memori dinamik, yang membawa kepada kebocoran ingatan. Di sisi lain, pemusnah yang berlebihan boleh menyebabkan overhead prestasi yang tidak perlu.

Mari kita mulakan dengan contoh mudah untuk menggambarkan pemusnah asas:

 kelas SimpleResource {
awam:
    SimpleResource () {
        std :: cout << "Sumber yang diperoleh." << std :: endl;
    }

    ~ SimpleResource () {
        std :: cout << "Sumber dikeluarkan." << std :: endl;
    }
};

int main () {
    {
        SimpleResource Resource;
    } // sumber keluar dari skop di sini, Destructor dipanggil
    kembali 0;
}

Dalam contoh ini, pemusnah secara automatik dipanggil apabila resource keluar dari skop. Ini cara yang mudah untuk memastikan sumber dikeluarkan. Walau bagaimanapun, perkara menjadi lebih menarik apabila berurusan dengan ingatan dinamik.

Pertimbangkan kelas yang menguruskan array yang diperuntukkan secara dinamik:

 Kelas DynamicArray {
Swasta:
    int* data;
    saiz int;

awam:
    DynamicArray (int s): saiz (s) {
        data = int baru [saiz];
        std :: cout << "array dinamik yang dibuat dengan saiz" << saiz << std :: endl;
    }

    ~ DynamicArray () {
        padam [] data;
        std :: cout << "Arahan dinamik dimusnahkan." << std :: endl;
    }
};

int main () {
    DynamicArray ARR (10);
    kembali 0;
}

Di sini, pemusnah adalah penting untuk membebaskan memori yang diperuntukkan dengan new[] . Tanpa itu, anda akan mempunyai kebocoran ingatan. Satu perangkap untuk diperhatikan adalah peraturan tiga/lima/sifar: Jika anda menentukan pemusnah, anda juga harus mempertimbangkan untuk menentukan pembina salinan dan pengendali tugasan untuk memastikan pengurusan sumber yang betul.

Sekarang, mari kita meneroka senario yang lebih kompleks dengan kelas menguruskan fail:

 #include <fstream>
#include <string>

kelas fileManager {
Swasta:
    std :: fstream file;

awam:
    FileManager (const std :: string & filename) {
        File.Open (FileName, std :: ios :: out | std :: ios :: app);
        jika (! file.is_open ()) {
            membuang std :: runtime_error ("tidak dapat membuka fail");
        }
        std :: cout << "Fail dibuka:" << filename << std :: endl;
    }

    ~ FileManager () {
        jika (file.is_open ()) {
            file.close ();
            std :: cout << "Fail ditutup." << std :: endl;
        }
    }

    void write (const std :: string & content) {
        jika (file.is_open ()) {
            Fail << kandungan << std :: endl;
        }
    }
};

int main () {
    Cuba {
        Pengurus FileManager ("example.txt");
        pengurus.write ("Hello, World!");
    } tangkapan (const std :: exception & e) {
        std :: cerr << "error:" << e.what () << std :: endl;
    }
    kembali 0;
}

Dalam contoh ini, pemusnah memastikan bahawa fail ditutup dengan betul, walaupun pengecualian berlaku. Ini adalah aspek kritikal pengurusan sumber dalam c.

Satu perkara yang saya pelajari dengan cara yang sukar ialah pemusnah boleh memberi kesan yang signifikan terhadap prestasi, terutamanya dalam senario frekuensi tinggi. Sebagai contoh, jika anda berurusan dengan kelas yang sering dibuat dan dimusnahkan, pemusnah kompleks mungkin memperkenalkan overhead yang tidak perlu. Adalah penting untuk memaparkan kod anda dan mempertimbangkan perdagangan.

Satu lagi pertimbangan penting ialah perintah kemusnahan dalam hierarki warisan. Pertimbangkan contoh ini:

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

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

int main () {
    Diperolehi;
    kembali 0;
}

Output akan:

 Pemusnahan yang diperolehi yang dipanggil.
Destructor asas dipanggil.

Perintah ini (diperolehi sebelum asas) adalah penting untuk difahami, kerana ia memastikan bahawa sumber kelas yang diperolehi dibebaskan sebelum sumber kelas asas. Salah faham ini boleh membawa kepada kebocoran sumber atau tingkah laku yang tidak ditentukan.

Kesimpulannya, pemusnah dalam C adalah alat yang berkuasa untuk pengurusan sumber, tetapi mereka datang dengan cabaran dan pertimbangan mereka sendiri. Sentiasa fikirkan peraturan tiga/lima/sifar, berhati -hati dengan implikasi prestasi, dan memahami perintah kemusnahan dalam hierarki warisan. Dengan pandangan dan contoh praktikal ini, anda akan dilengkapi dengan lebih baik untuk menulis kod C yang mantap dan cekap.

Atas ialah kandungan terperinci C Destructors: Contoh kod praktikal. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!