Pengaturcaraan C++ ialah bahasa terbaik kerana ia memudahkan kami dengan pelbagai fungsi, pembina, fail pengepala, kelas dan banyak lagi, menjadikan pengekodan lebih menarik dan lebih mudah. Salah satu pembina dalam pengaturcaraan C++ ialah pembina 'move'. Pembina 'move' ialah sejenis pembina unik yang membenarkan pemilikan memori yang diperuntukkan secara dinamik atau sumber lain dipindahkan dari satu objek ke objek lain dengan cara yang berkesan dan mementingkan sumber.
Dalam pengaturcaraan C++, pembina 'move' telah diperkenalkan untuk mengurangkan pertindihan dan meningkatkan kecekapan. Ia memainkan peranan penting dalam meningkatkan prestasi dengan meminimumkan operasi penyalinan. Panduan ini meneroka secara mendalam tentang pembina 'move' dalam pengaturcaraan C++.
Contoh 1:
Untuk memulakan kod di sini, kami memasukkan fail pengepala 'iostream' dan 'rentetan' yang akan menjadikan kod kami berjalan dengan sempurna kerana banyak fungsi diisytiharkan dalam fail pengepala ini. Apabila kita perlu menggunakan pernyataan 'cout', fail pengepala 'iostream' digunakan kerana fungsi ini diisytiharkan di dalam ini. Apabila kita perlu bekerja dengan data jenis rentetan, fail pengepala 'rentetan' diperlukan.
Selepas ini, 'ruang nama std' ditambah di bawah fail pengepala ini. Kemudian, kami membina kelas di sini. Nama kelas ialah “Move”. Di bawah ini, kata kunci 'peribadi' ditambahkan di mana kami mengisytiharkan pembolehubah rentetan peribadi dengan nama 'my_str'. Sekarang, kami meletakkan kata kunci 'awam' di mana kami menambah definisi pembina lalai. Kami menghantar 'Ini adalah rentetan lalai di sini' kepada 'my_str' sebagai parameter dan biarkan pembina lalai kosong.
Selepas ini, kami menyalin definisi pembina dan memulakan 'my_str' kepada 'my_obj.my_str'. Di bawah ini, kami mencetak garis dan kemudian meletakkan definisi pembina 'gerakan'. Di sini, kami memulakan 'my_str' sekali lagi dengan 'my_obj.my_str'. Kami tidak menambah sebarang kenyataan di bawah ini; ia kosong. Selepas ini, kami mengisytiharkan fungsi bernama 'displayMyObject()' jenis rentetan dan menggunakan 'return str' supaya ia mengembalikan rentetan.
Kami meletakkan fungsi 'new_temp' global dalam jenis 'move'. Di bawahnya, kami mempunyai 'tempoh pulangan' yang mengembalikan objek jenis pergerakan. Sekarang, kami meletakkan kod pemacu 'main()' dan 'new_obj1' jenis 'move' dan dapatkan pembina 'move' daripada 'rvalue'. Dalam barisan hadapan, kami meletakkan 'new_obj1.displayMyObject()' untuk mendapatkan pembina 'move' daripada 'lvalue'. Selepas ini, kami memanggil pembina 'move' dengan objek 'my_obj1'. Kemudian, kami memindahkan pemilikan 'my_obj1' kepada objek lain iaitu 'my_obj2'.
Kod 1:
#include#include
menggunakan ruang nama std ;
kelas Bergerak
{
persendirian :
rentetan my_str ;
awam :
Bergerak ( ) : my_str ( 'Ini ialah rentetan lalai di sini' )
{
}
Bergerak ( const Bergerak & my_obj ) : my_str ( my_obj. my_str )
{
cout << 'Pembina salin dipanggil, Pindah gagal! \n ' ;
}
Bergerak ( Bergerak && my_obj ) : my_str ( bergerak ( my_obj. my_str ) )
{
}
paparan rentetanMyObject ( )
{
kembali my_str ;
}
} ;
Alihkan new_temp ( Gerakkan tmp )
{
kembali tmp ;
}
int utama ( )
{
Alihkan new_obj1 = new_temp ( Bergerak ( ) ) ;
cout << 'sebelum pindah() panggil : new_obj1 = ' << new_obj1. paparanMyObject ( ) << endl ;
Alihkan new_obj2 = bergerak ( new_obj1 ) ;
cout << 'selepas pindah() panggil pembina : new_obj1 = ' << new_obj1. paparanMyObject ( ) << endl ;
cout << 'selepas pindah() panggilan pembina : new_obj2 = ' << new_obj2. paparanMyObject ( ) << endl ;
kembali 0 ;
}
Pengeluaran:
Output menjadikan bahawa sebelum memanggil kaedah 'move()', 'new_obj1' mengandungi rentetan lalai. Tetapi selepas memanggil kaedah 'Move' class move(), 'my_obj1' mengandungi rentetan kosong dan 'my_obj2' mempunyai rentetan lalai.
Contoh 2:
Di sini, kami memasukkan satu lagi fail pengepala iaitu fail pengepala 'vektor'. Kami memasukkan ini apabila kami perlu memanipulasi operasi pada vektor. Kelas yang kami buat di sini ialah kelas 'Alih'. Kami juga mencipta pembina 'awam' di sini di mana kami mengisytiharkan penunjuk mentah 'nilai* int' sebagai data ahli kelas. Di bawahnya, kami mempunyai 'awam' di mana kami meletakkan pembina 'Move' dan lulus 'int v1' sebagai parameternya.
Selepas ini, kami mengisytiharkan objek dalam timbunan. Kami memulakan 'nilai' dengan 'int baharu' dan '*nilai' dengan 'v1'. Kemudian, letakkan 'cout' di mana kita menambah baris yang dicetak apabila kita melaksanakan kod. Di bawah ini, kami menggunakan pembina 'salinan'. Pembina 'salinan' ini menyalin data dengan membuat salinan dalam. Kami meletakkan pembina 'Move' dan lulus 'Move&& new_source' sebagai parameternya. Di bawahnya, kami meletakkan 'cout' yang membantu dalam memaparkan pernyataan yang diperlukan.
Kami memasukkan kata kunci 'nullptr' untuk menentukan sama ada penuding kosong sebelum rujukan digunakan. Sekarang, kami juga meletakkan pemusnah '~Move()' di mana kami meletakkan syarat 'if' yang mengesahkan sama ada 'nilai' tidak sama dengan 'nullptr'. Apabila syarat ini disahkan, pernyataan di bawah ini dilaksanakan. Jika syarat ini tidak disahkan, ia melangkau pernyataan 'cout' yang hadir selepas keadaan 'jika' dan bergerak ke arah bahagian 'lain'.
Selepas ini, kami menggunakan kata kunci 'padam' yang membantu dalam menentukan lokasi objek atau kita boleh mengatakan bahawa ia mengeluarkan memori yang diperuntukkan kepada komponen data objek. Sekarang, kami menggunakan kaedah 'main()' di sini dan mencipta vektor kelas 'Move' kami dengan nama, 'my_vec'. Selepas ini, kami menggunakan fungsi 'push_back()' yang membantu untuk memasukkan nilai pada titik akhir vektor. Fail pengepala 'vektor' mengandungi fungsi ini. Pertama, kami memasukkan '39' ke dalam vektor. Kemudian, '57' dimasukkan dan '91' juga dimasukkan dengan menggunakan kaedah 'push_back()'.
Kod 2:
#include#include
menggunakan ruang nama std ;
kelas Bergerak {
persendirian :
int * nilai ;
awam :
Bergerak ( int v1 )
{
nilai = baru int ;
* nilai = v1 ;
cout << 'Pembina dipanggil untuk'
<< v1 << endl ;
} ;
Bergerak ( const Bergerak & sumber_baru )
: Bergerak { * sumber_baru. nilai }
{
cout << 'Pembina Salin dipanggil -'
<< 'Salinan dalam untuk'
<< * sumber_baru. nilai
<< endl ;
}
Bergerak ( Bergerak && sumber_baru )
: nilai { sumber_baru. nilai }
{
cout << 'Pindahkan Pembina untuk'
<< * sumber_baru. nilai << endl ;
sumber_baru. nilai = nullptr ;
}
~Bergerak ( )
{
jika ( nilai ! = nullptr )
cout << 'Pemusnah dipanggil untuk'
<< * nilai << endl ;
lain
cout << 'Pemusnah dipanggil'
<< 'untuk nullptr'
<< endl ;
padam nilai ;
}
} ;
int utama ( )
{
vektor < Bergerak > my_thing ;
my_thing. menolak kembali ( Bergerak { 39 } ) ;
my_thing. menolak kembali ( Bergerak { 57 } ) ;
my_thing. menolak kembali ( Bergerak { 91 } ) ;
kembali 0 ;
}
Pengeluaran:
Ini menunjukkan bahawa daripada menggunakan fungsi 'salin', kita perlu menggunakan fungsi 'pindah' untuk mengelakkan panggilan yang tidak perlu kepada fungsi 'salin'. Pembina 'move' digunakan di sini apabila kita memulakan objek dengan objek sementara atau beberapa objek yang akan dimusnahkan. Daripada memanipulasi salinan mendalam data yang diberikan, pembina 'gerakkan' mengalihkan pemilikan sumber dari satu objek ke objek lain.
Kesimpulan
Dalam panduan ini, kami meneroka tentang pembina 'bergerak'. Kami menjelaskan bahawa pembina 'move' dalam pengaturcaraan C++ ialah kaedah unik untuk menempatkan semula sumber objek ke objek lain dengan berkesan. Kami membincangkan bahawa memanggil pembina 'move' mempunyai overhead yang lebih sedikit, menjadikan kod lebih cekap memori. Kami meneroka fakta bahawa pembina 'move' ialah ciri yang berkuasa dalam pengaturcaraan C++. Kami juga menggunakan contoh praktikal untuk menggambarkan konsep pembina 'move' dan menunjukkan faedah prestasi menggunakan pembina 'move' dalam pengaturcaraan C++.