Pemusnah C boleh membawa kepada beberapa kesilapan biasa. Untuk mengelakkannya: 1) Mencegah penghapusan ganda dengan menetapkan petunjuk ke Nullptr atau menggunakan petunjuk pintar. 2) Mengendalikan pengecualian dalam pemusnah dengan menangkap dan membalut mereka. 3) Gunakan pemusnah maya dalam kelas asas untuk kemusnahan polimorfik yang betul. 4) Menguruskan perintah kemusnahan dalam hierarki kompleks dengan berhati -hati. Menggunakan RAII dan penunjuk pintar untuk pengurusan sumber yang lebih baik.

Ketika datang ke pemusnah C, ada seluruh dunia kerumitan dan kehalusan yang dapat mengembara bahkan pemaju yang berpengalaman. Mari kita menyelam kesilapan umum yang berkaitan dengan pemusnah dan meneroka cara menavigasi perairan yang rumit ini.

Pemusnah C adalah fungsi ahli khas yang dipanggil apabila hayat objek berakhir. Mereka sangat penting untuk membersihkan sumber, seperti memori atau pemegang fail, bahawa objek mungkin dipegang. Walau bagaimanapun, jika tidak ditangani dengan betul, pemusnah boleh membawa kepada pelbagai isu, dari kebocoran memori hingga tingkah laku yang tidak dijangka.

Salah satu kesilapan yang paling biasa yang saya temui dalam tahun pengekodan saya ialah penghapusan dua objek. Ini biasanya berlaku apabila anda mempunyai penunjuk ke objek, dan anda memadamkannya secara manual, tetapi kemudian pemusnah objek lain cuba memadamnya lagi. Mari lihat contoh untuk memahami perkara ini dengan lebih baik:

 sumber kelas {
awam:
    ~ Sumber () {
        padam [] data;
    }

Swasta:
    int* data;
};

pemilik kelas {
awam:
    ~ Pemilik () {
        padam sumber;
    }

Swasta:
    Sumber* sumber;
};

int main () {
    Pemilik* pemilik = pemilik baru ();
    pemilik-> sumber = sumber baru ();
    memadam pemilik; // ini akan memadamkan objek sumber
    padam pemilik-> sumber; // ini akan menyebabkan ralat penghapusan berganda
    kembali 0;
}

Dalam kod ini, kami mempunyai kelas Resource yang menguruskan pelbagai bilangan bulat, dan kelas Owner yang memiliki Resource . Masalahnya timbul apabila kita memadamkan objek Resource secara manual selepas Owner telah dipadamkan, yang seterusnya cuba memadam Resource dalam pemusnahnya. Untuk mengelakkan ini, kita perlu menetapkan penunjuk ke nullptr selepas penghapusan atau menggunakan petunjuk pintar.

Satu lagi kesilapan yang kerap tidak mengendalikan pengecualian dengan betul dalam pemusnah. Sekiranya pemusnah melemparkan pengecualian, ia boleh menyebabkan tingkah laku yang tidak ditentukan, terutamanya jika objek itu dimusnahkan sebagai sebahagian daripada stack yang tidak diingini semasa pengendalian pengecualian. Inilah cara anda dapat menemui ini:

 Kelas FileHandler {
awam:
    ~ FileHandler () {
        jika (file.is_open ()) {
            file.close ();
            jika (! file.good ()) {
                membuang std :: runtime_error ("Fail penutupan ralat");
            }
        }
    }

Swasta:
    std :: fstream file;
};

Dalam contoh ini, jika file.close() gagal dan melemparkan pengecualian, program itu boleh terhempas atau berkelakuan tidak dapat diramalkan. Pendekatan yang lebih baik adalah untuk menangkap dan mengendalikan pengecualian dalam pemusnah:

 Kelas FileHandler {
awam:
    ~ FileHandler () {
        Cuba {
            jika (file.is_open ()) {
                file.close ();
                jika (! file.good ()) {
                    // log ralat tetapi jangan buang
                    std :: Cerr << "Fail penutupan ralat" << std :: endl;
                }
            }
        } tangkapan (const std :: exception & e) {
            std :: Cerr << "Pengecualian dalam Destructor:" << E.What () << std :: endl;
        }
    }

Swasta:
    std :: fstream file;
};

Sekarang, mari kita bincangkan masalah pemusnah maya. Jika anda bekerja dengan warisan dan polimorfisme, gagal mengisytiharkan pemusnah maya di kelas asas boleh membawa kepada tingkah laku yang tidak ditentukan apabila memadamkan objek yang diperoleh melalui penunjuk kelas asas. Inilah contoh:

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

kelas yang diperolehi: asas awam {
awam:
    ~ Berasal () {
        std :: cout << "Derive Derructor" << std :: endl;
    }
};

int main () {
    Asas* asas = baru diperoleh ();
    padam asas; // hanya pemusnah asas dipanggil
    kembali 0;
}

Dalam kes ini, hanya pemusnah Base yang dipanggil, meninggalkan sumber objek Derived tidak jelas. Untuk membetulkannya, kita perlu membuat asas pemusnah Base :

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

kelas yang diperolehi: asas awam {
awam:
    ~ Berasal () {
        std :: cout << "Derive Derructor" << std :: endl;
    }
};

int main () {
    Asas* asas = baru diperoleh ();
    padam asas; // Pemusnahan asas dan asas dipanggil
    kembali 0;
}

Satu lagi isu halus ialah perintah kemusnahan dalam hierarki kelas kompleks. Sekiranya anda mempunyai pelbagai objek dengan pemusnah yang bergantung kepada satu sama lain, anda perlu berhati -hati tentang susunan di mana ia dimusnahkan. Ini boleh menjadi sangat sukar dengan objek statik, di mana perintah kemusnahan pada penamatan program tidak dijamin. Inilah senario untuk menggambarkan:

 Kelas A {
awam:
    ~ A () {
        std :: cout << "a dimusnahkan" << std :: endl;
    }
};

Kelas B {
awam:
    ~ B () {
        std :: cout << "b dimusnahkan" << std :: endl;
    }
};

A A;
B b;

int main () {
    kembali 0;
}

Perintah di mana a dan b dimusnahkan tidak dijamin, yang boleh menyebabkan tingkah laku yang tidak dijangka jika pemusnah mereka berinteraksi. Untuk mengurangkan ini, anda mungkin perlu menggunakan teknik seperti suntikan ketergantungan atau dengan teliti menguruskan seumur hidup objek.

Dalam pengalaman saya, salah satu amalan terbaik untuk mengelakkan isu -isu ini adalah menggunakan RAII (pengambilalihan sumber adalah permulaan) dan penunjuk pintar. RAII memastikan bahawa sumber -sumber diuruskan dengan betul dengan mengikat mereka ke seumur hidup objek, dan penunjuk pintar seperti std::unique_ptr dan std::shared_ptr dapat membantu menguruskan jangka hayat objek dan mencegah penghapusan ganda.

Sebagai contoh, menggunakan std::unique_ptr boleh menyelesaikan masalah penghapusan ganda:

 sumber kelas {
awam:
    ~ Sumber () {
        padam [] data;
    }

Swasta:
    int* data;
};

pemilik kelas {
awam:
    ~ Pemilik () = lalai;

Swasta:
    std :: unik_ptr <sources> sumber;
};

int main () {
    pemilik auto = std :: make_unique <owner> ();
    pemilik-> sumber = std :: make_unique <sources> ();
    kembali 0;
}

Dalam versi yang disemak ini, objek Resource dikendalikan oleh std::unique_ptr , yang memastikan ia dipadamkan hanya sekali apabila objek Owner dimusnahkan.

Untuk membungkus, memahami dan melaksanakan pemusnah dengan betul dalam C adalah penting untuk menulis kod yang mantap dan cekap. Dengan menyedari kesilapan biasa seperti penghapusan ganda, pengendalian pengecualian dalam pemusnah, isu pemusnah maya, dan perintah pemusnahan, anda boleh mengelakkan banyak perangkap. Merangkul ciri -ciri C moden seperti Pointers Pintar dan RAII dapat memudahkan pengurusan sumber dan menjadikan kod anda lebih dipercayai. Terus bereksperimen, dan jangan takut untuk menyelam jauh ke dalam selok -belok c -Ia adalah perjalanan yang mencabar dan bermanfaat!

Atas ialah kandungan terperinci D Destructors: Kesalahan biasa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!