pengantar
C ++ memperlakukan variabel tipe yang ditentukan pengguna dengan semantik nilai . Ini berarti bahwa objek secara tersirat disalin dalam berbagai konteks, dan kita harus memahami apa sebenarnya arti "menyalin objek".
Mari kita perhatikan contoh sederhana:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age) : name(name), age(age)
{
}
};
int main()
{
person a("Bjarne Stroustrup", 60);
person b(a); // What happens here?
b = a; // And here?
}
(Jika Anda bingung dengan name(name), age(age)bagian ini, ini disebut daftar penginisialisasi anggota .)
Fungsi anggota khusus
Apa artinya menyalin personobjek? The mainFungsi menunjukkan dua skenario menyalin berbeda. Inisialisasi person b(a);dilakukan oleh copy constructor . Tugasnya adalah membangun objek baru berdasarkan keadaan objek yang ada. Penugasan b = adilakukan oleh operator penugasan salinan . Pekerjaannya umumnya sedikit lebih rumit, karena objek target sudah dalam keadaan valid yang perlu ditangani.
Karena kami mendeklarasikan bukan pembuat salinan atau operator penugasan (atau destruktor) sendiri, ini secara implisit didefinisikan untuk kami. Kutipan dari standar:
Operator penyalin dan penyalin salin [...], [...] dan destruktor adalah fungsi anggota khusus. [ Catatan : Implementasi secara implisit akan mendeklarasikan fungsi anggota ini untuk beberapa tipe kelas ketika program tidak secara eksplisit mendeklarasikannya.
Implementasi akan secara implisit menentukan mereka jika digunakan. [...] catatan akhir ] [n3126.pdf bagian 12 §1]
Secara default, menyalin objek berarti menyalin anggotanya:
Konstruktor salinan yang terdefinisi secara implisit untuk kelas X non-serikat melakukan salinan anggota sub-proyeknya. [n3126.pdf bagian 12.8 §16]
Operator penugasan salinan yang ditentukan secara implisit untuk kelas X non-serikat pekerja melakukan penugasan salin anggota dari sub-proyeknya. [n3126.pdf bagian 12.8 §30]
Definisi tersirat
Fungsi anggota khusus yang didefinisikan secara implisit untuk personterlihat seperti ini:
// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}
// 2. copy assignment operator
person& operator=(const person& that)
{
name = that.name;
age = that.age;
return *this;
}
// 3. destructor
~person()
{
}
Penyalinan dengan anggota adalah yang kita inginkan dalam kasus ini:
namedan agedisalin, jadi kita mendapatkan personobjek mandiri yang mandiri . Destructor yang didefinisikan secara implisit selalu kosong. Ini juga baik dalam hal ini karena kami tidak memperoleh sumber daya apa pun di konstruktor. Destructor anggota secara implisit dipanggil setelah persondestruktor selesai:
Setelah mengeksekusi tubuh destruktor dan menghancurkan objek otomatis yang dialokasikan dalam tubuh, destruktor untuk kelas X memanggil destruktor untuk anggota langsung [...] [n3126.pdf 12.4 §6]
Mengelola sumber daya
Jadi kapan kita harus mendeklarasikan fungsi anggota khusus itu secara eksplisit? Ketika kelas kita mengelola sumber daya , yaitu, ketika sebuah objek kelas bertanggung jawab atas sumber daya itu. Itu biasanya berarti sumber daya diperoleh dalam konstruktor (atau diteruskan ke konstruktor) dan dirilis pada destruktor.
Mari kita kembali ke masa pra-standar C ++. Tidak ada yang namanya std::string, dan programmer suka dengan pointer. The personkelas mungkin tampak seperti ini:
class person
{
char* name;
int age;
public:
// the constructor acquires a resource:
// in this case, dynamic memory obtained via new[]
person(const char* the_name, int the_age)
{
name = new char[strlen(the_name) + 1];
strcpy(name, the_name);
age = the_age;
}
// the destructor must release this resource via delete[]
~person()
{
delete[] name;
}
};
Bahkan hari ini, orang masih menulis kelas dengan gaya ini dan mendapat masalah: " Saya mendorong seseorang ke vektor dan sekarang saya mendapatkan kesalahan memori gila! " Ingat bahwa secara default, menyalin objek berarti menyalin anggota, tetapi menyalin nameanggota hanya menyalin sebuah pointer, bukan array karakter yang ditunjuknya! Ini memiliki beberapa efek yang tidak menyenangkan:
- Perubahan melalui
adapat diamati melalui b.
- Setelah
bdihancurkan, a.nameadalah pointer menjuntai.
- Jika
adihancurkan, menghapus pointer menggantung menghasilkan perilaku yang tidak terdefinisi .
- Karena tugas tidak memperhitungkan apa yang
namemenunjuk sebelum tugas, cepat atau lambat Anda akan mendapatkan kebocoran memori di semua tempat.
Definisi eksplisit
Karena penyalinan dengan anggota tidak memiliki efek yang diinginkan, kita harus mendefinisikan konstruktor salin dan operator penugasan secara eksplisit untuk membuat salinan mendalam dari susunan karakter:
// 1. copy constructor
person(const person& that)
{
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
// 2. copy assignment operator
person& operator=(const person& that)
{
if (this != &that)
{
delete[] name;
// This is a dangerous point in the flow of execution!
// We have temporarily invalidated the class invariants,
// and the next statement might throw an exception,
// leaving the object in an invalid state :(
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
return *this;
}
Perhatikan perbedaan antara inisialisasi dan penugasan: kita harus merobohkan keadaan lama sebelum menugaskan nameuntuk mencegah kebocoran memori. Juga, kita harus melindungi diri dari penugasan formulir x = x. Tanpa centang itu, delete[] nameakan menghapus array yang berisi string sumber , karena ketika Anda menulis x = x, keduanya this->namedan that.nameberisi pointer yang sama.
Keamanan pengecualian
Sayangnya, solusi ini akan gagal jika new char[...]melempar pengecualian karena kehabisan memori. Salah satu solusi yang mungkin adalah dengan memperkenalkan variabel lokal dan menyusun ulang pernyataan:
// 2. copy assignment operator
person& operator=(const person& that)
{
char* local_name = new char[strlen(that.name) + 1];
// If the above statement throws,
// the object is still in the same state as before.
// None of the following statements will throw an exception :)
strcpy(local_name, that.name);
delete[] name;
name = local_name;
age = that.age;
return *this;
}
Ini juga menangani penugasan diri tanpa pemeriksaan eksplisit. Solusi yang lebih kuat untuk masalah ini adalah idiom copy-and-swap , tapi saya tidak akan membahas detail keamanan pengecualian di sini. Saya hanya menyebutkan pengecualian untuk membuat poin berikut: Menulis kelas yang mengelola sumber daya sulit.
Sumber daya yang tidak dapat didokumentasikan
Beberapa sumber daya tidak dapat atau tidak boleh disalin, seperti pegangan file atau mutex. Dalam hal itu, cukup deklarasikan copy constructor dan copy assignment operator privatetanpa memberikan definisi:
private:
person(const person& that);
person& operator=(const person& that);
Atau, Anda dapat mewarisi boost::noncopyableatau mendeklarasikannya sebagai dihapus (dalam C ++ 11 dan di atas):
person(const person& that) = delete;
person& operator=(const person& that) = delete;
Aturan tiga
Terkadang Anda perlu mengimplementasikan kelas yang mengelola sumber daya. (Jangan pernah mengelola banyak sumber daya dalam satu kelas, ini hanya akan menimbulkan rasa sakit.) Dalam hal ini, ingat aturan tiga :
Jika Anda perlu secara eksplisit mendeklarasikan baik destruktor, copy constructor atau operator penugasan sendiri, Anda mungkin perlu secara eksplisit mendeklarasikan ketiganya.
(Sayangnya, "aturan" ini tidak ditegakkan oleh standar C ++ atau kompiler apa pun yang saya ketahui.)
Aturan lima
Dari C ++ 11 dan seterusnya, sebuah objek memiliki 2 fungsi anggota khusus ekstra: konstruktor pemindahan dan pemindahan tugas. Aturan lima negara untuk mengimplementasikan fungsi-fungsi ini juga.
Contoh dengan tanda tangan:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age); // Ctor
person(const person &) = default; // Copy Ctor
person(person &&) noexcept = default; // Move Ctor
person& operator=(const person &) = default; // Copy Assignment
person& operator=(person &&) noexcept = default; // Move Assignment
~person() noexcept = default; // Dtor
};
Aturan nol
Aturan 3/5 juga disebut sebagai aturan 0/3/5. Bagian nol dari aturan menyatakan bahwa Anda diizinkan untuk tidak menulis fungsi anggota khusus saat membuat kelas Anda.
Nasihat
Sebagian besar waktu, Anda tidak perlu mengelola sumber daya sendiri, karena kelas yang ada seperti std::stringsudah melakukannya untuk Anda. Bandingkan saja kode sederhana menggunakan std::stringanggota dengan alternatif berbelit-belit dan rawan menggunakan char*dan Anda harus diyakinkan. Selama Anda tinggal jauh dari anggota pointer mentah, aturan tiga kemungkinan tidak akan menyangkut kode Anda sendiri.
c++-faqtag wiki sebelum Anda memilih untuk menutup .