Di antara banyak operasi yang tersedia untuk 'std::map', fungsi 'padam' menonjol sebagai alat penting untuk mengalih keluar elemen berdasarkan kekuncinya. 'std::map' ialah bekas bersekutu teratur yang terdiri daripada pasangan nilai kunci. Susunan elemen dalam 'std::map' diisih secara konsisten mengikut kekuncinya, memudahkan operasi yang berkesan seperti carian, sisipan dan pemadaman berdasarkan nilai utama.
Dalam bidang C++, fungsi 'std::map::erase' berfungsi sebagai fungsi ahli kelas 'std::map', membolehkan penyingkiran elemen tertentu daripada peta. Ia datang dalam pelbagai bentuk, memberikan fleksibiliti dalam menentukan elemen yang hendak dipadamkan. Dalam artikel ini, kami akan menyelidiki butiran 'std::map::erase', memberikan berbilang contoh untuk menggambarkan kepelbagaiannya.
Contoh 1: Memadam dengan Kunci
Keupayaan untuk memadamkan elemen dengan kunci dalam 'std::map' ialah ciri asas yang disediakan oleh Perpustakaan Templat Standard C++. Operasi ini biasanya digunakan apabila anda perlu mengurus dan memanipulasi pasangan nilai kunci dalam program, dan ia menyediakan cara yang mudah untuk mengalih keluar elemen tertentu berdasarkan kuncinya. Kami akan membuat contoh untuk menunjukkan cara menggunakan 'std::map' untuk mencipta peta, memadam elemen dengan kunci, dan kemudian memaparkan peta yang diubah suai.
#include
#include
int utama ( ) {
std::peta < int, std::string > myMap;
myMap [ 1 ] = 'Merah' ;
myMap [ 2 ] = 'Biru' ;
myMap [ 3 ] = 'Hijau' ;
myMap.erase ( 2 ) ;
untuk ( const auto & pasangan : myMap ) {
std::cout << berpasangan.pertama << ': ' << pasangan.kedua << std::endl;
}
kembali 0 ;
}
Dalam contoh ini, kita mulakan dengan memasukkan perpustakaan standard C++ yang diperlukan seperti
Untuk mempamerkan keadaan peta yang terhasil, kami menggunakan gelung 'untuk' yang berulang melalui setiap pasangan nilai kunci dalam 'myMap'. Kami menggunakan objek 'std::cout' di dalam gelung untuk mencetak setiap pasangan nilai kunci ke konsol. Akhir sekali, pernyataan 'return 0' menyimpulkan fungsi 'utama' yang menandakan kejayaan pelaksanaan program kami.
Output memaparkan pasangan nilai kunci yang tinggal dalam 'std::map' selepas elemen dengan kunci 2 ('Biru') dipadamkan yang menghasilkan output '1: Merah' dan '3: Hijau'.
Contoh 2: Memadam dengan Iterator
Dalam C++, iterator ialah objek yang memudahkan navigasi elemen dalam bekas, menawarkan cara untuk mengakses, mengubah suai atau mengalih keluar elemen. Fungsi 'std::map::erase' juga boleh digunakan dengan iterator untuk mengalih keluar elemen.
Berikut adalah contoh:
#include#include
int utama ( ) {
std::peta < int, std::string > fruitFolder;
fruitFolder [ 1 ] = 'Mangga' ;
fruitFolder [ 2 ] = 'Oren' ;
fruitFolder [ 3 ] = 'Nenas' ;
fruitFolder [ 4 ] = 'Anggur' ;
auto ia = fruitMap.find ( 2 ) ;
jika ( ia ! = fruitMap.end ( ) ) {
fruitMap.erase ( ia ) ;
}
untuk ( const auto & pasangan : fruitMap ) {
std::cout << berpasangan.pertama << ': ' << pasangan.kedua << std::endl;
}
kembali 0 ;
}
Kod C++ yang disediakan bermula dengan mengisytiharkan 'std::map' bernama 'fruitMap' untuk menyimpan pasangan nilai kunci, mengaitkan integer dengan nama buah yang sepadan. Kami mengisi peta dengan entri untuk empat buah yang berbeza: 'Mangga', 'Oren', 'PineApple' dan 'Anggur'. Selepas itu, kami menggunakan fungsi 'cari' untuk mendapatkan iterator (ia) yang menunjuk kepada elemen dengan nilai kunci 2 dalam 'fruitMap'. Kemudian, kami menyemak sama ada iterator tidak sama dengan 'end()' untuk memastikan elemen dengan kunci yang ditentukan wujud dalam peta.
Dalam blok bersyarat, kami memadamkan elemen yang ditunjuk oleh lelaran 'ia' menggunakan fungsi 'padam'. Akhir sekali, kami mengulangi elemen yang tinggal dalam 'fruitMap' yang diubah suai menggunakan gelung 'untuk'.
Output akhir memaparkan kandungan 'fruitMap' yang diubah suai selepas pemadaman.
Contoh 3: Memadam Julat
Bekas 'std::map' dalam C++ menyediakan kaedah yang mudah untuk memadamkan elemen dalam julat yang ditentukan. Fungsi 'padam' membolehkan anda mengalih keluar elemen dari peta berdasarkan iterator yang mewakili permulaan dan penghujung julat yang akan dipadamkan.
Sekarang, mari kita terokai konsep memadam julat menggunakan 'std::map' dengan contoh:
#include#include
int utama ( ) {
std::peta < int, std::string > Peta baru;
Peta baru [ 1 ] = 'Kuda' ;
Peta baru [ 2 ] = 'Singa' ;
Peta baru [ 3 ] = 'Harimau' ;
Peta baru [ 4 ] = 'Kucing' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
untuk ( const auto & pasangan: newMap ) {
std::cout << berpasangan.pertama << ': ' << pasangan.kedua << std::endl;
}
kembali 0 ;
}
Program ini bermula dengan mengisytiharkan 'std::map' bernama 'newMap' yang mengaitkan kunci integer dengan nilai rentetan yang sepadan. Selepas itu, kami mengisi peta dengan pasangan nilai kunci menggunakan operator kurungan segi empat sama. Sebagai contoh, kami menetapkan pasangan nilai kunci (1, 'Kuda'), (2, 'Singa'), (3, 'Harimau') dan (4, 'Kucing') kepada 'Peta baharu'.
Operasi penting seterusnya melibatkan penggunaan iterator untuk memadamkan elemen daripada peta. Fungsi padam digunakan dengan argumen 'newMap.lower_bound(2)' dan 'newMap.upper_bound(3)'. Ini memadamkan elemen dengan kunci yang berada dalam julat (2, 3). Dalam erti kata lain, ia mengalih keluar masukan 'Singa' dan 'Harimau' daripada peta. Selepas operasi ini, peta hanya mengandungi elemen dengan kekunci 1 dan 4, sepadan dengan 'Kuda' dan 'Kucing'.
Akhir sekali, kami menggunakan gelung 'untuk' berasaskan julat untuk mengulangi elemen yang tinggal dalam peta dan mencetak pasangan nilai kunci mereka ke konsol.
Akibatnya, output memaparkan perkara berikut:
Contoh 4: Memadam Berdasarkan Predikat
Pemadaman berdasarkan predikat merujuk kepada mengalih keluar elemen daripada struktur data, seperti bekas, berdasarkan syarat atau kriteria tertentu. 'std::map::erase' juga boleh digunakan dengan fungsi predikat untuk mengalih keluar elemen secara bersyarat. Mari kita pertimbangkan contoh berikut:
#include#include
#include
int utama ( ) {
std::peta < int, std::string > myMap = {
{ 1 , 'Januari' } ,
{ 2 , 'Februari' } ,
{ 3 , 'Mac' } ,
{ 4 , 'April' } ,
{ 5 , 'Mungkin' }
} ;
predikat auto = [ ] ( const std::pair < int, std::string >& unsur ) {
kembali unsur.kedua.panjang ( ) < 5 ;
} ;
myMap.erase ( std::remove_if ( myMap.begin ( ) , myMap.end ( ) , predikat ) , myMap.end ( ) ) ;
std::cout << ' \n Peta selepas memadamkan unsur berdasarkan predikat:' << std::endl;
untuk ( const auto & pasangan : myMap ) {
std::cout << berpasangan.pertama << ': ' << pasangan.kedua << std::endl;
}
kembali 0 ;
}
Program ini bermula dengan memasukkan fail pengepala yang diperlukan. 'std::map' dipanggil 'myMap' diisytiharkan dan dimulakan dalam fungsi 'utama'. Ia mengandungi pasangan nilai kunci yang mewakili nama bulan dan nilai berangka masing-masing. Selepas itu, fungsi 'lambda' (predikat) ditakrifkan. Fungsi 'lambda' ini berfungsi sebagai predikat untuk algoritma 'std::remove_if'. Ia mengesahkan jika panjang nilai rentetan yang dikaitkan dengan elemen peta adalah kurang daripada lima aksara.
Algoritma 'std::remove_if' kemudiannya digunakan bersama dengan fungsi 'padam' bagi 'std::map'. Gabungan ini mengeluarkan unsur-unsur daripada peta berdasarkan kesahihan predikat.
Selepas menjalankan program, elemen dengan kekunci kurang daripada lima dialih keluar daripada peta asal, menunjukkan pemadaman berdasarkan predikat menggunakan 'std::map'.
Kesimpulan
Kesimpulannya, fungsi 'std::map::erase' ialah alat serba boleh dalam C++ untuk mengalih keluar elemen daripada 'std::map'. Sama ada padam dengan kunci, lelaran, julat atau berdasarkan predikat, fungsi 'std::map::erase' menyediakan fleksibiliti dan kemudahan penggunaan. Dengan menguasai fungsi ini, pembangun C++ boleh mengurus dan memanipulasi data dengan cekap dalam bekas 'std::map', menjadikan kod mereka lebih kukuh dan lebih mudah untuk diselenggara.