Dalam pengaturcaraan C++, 'std::any' daripada Perpustakaan Templat Standard (STL) memperkenalkan penaipan dinamik untuk mengendalikan data heterogen. Tidak seperti bekas tradisional, 'std::any' membenarkan menyimpan nilai apa-apa jenis dalam satu bekas, meningkatkan fleksibiliti dalam senario di mana jenis data tidak diketahui atau berbeza-beza pada masa jalan. Pendekatan jenis-agnostik ini menggalakkan pengaturcaraan generik yang memberi kuasa kepada pembangun untuk mencipta kod yang lebih mudah disesuaikan dan ekspresif sambil mengekalkan keselamatan jenis. Dalam penerokaan ini, kita akan menyelidiki ciri 'std::any', corak penggunaannya dan contoh praktikal yang menggambarkan peranannya dalam menulis kod C++ yang mantap dan fleksibel.
Contoh 1: Penggunaan Asas Std:: Mana-mana
Mula-mula, mari kita terokai contoh mudah untuk menunjukkan penggunaan asas 'std:: any'. Pertimbangkan senario di mana anda memerlukan fungsi untuk menerima pelbagai jenis parameter:
Berikut ialah coretan kod:
#include
#include
proses batalMana-mana ( const std::mana-mana & nilai ) {
jika ( nilai.mempunyai_nilai ( ) ) {
std::cout << 'Jenis nilai yang disimpan: ' << jenis nilai ( ) .nama ( ) << std::endl;
jika ( jenis nilai ( ) == ditaip ( int ) ) {
std::cout << 'Nilai:' << std::any_cast < int > ( nilai ) << std::endl;
} lain jika ( jenis nilai ( ) == ditaip ( berganda ) ) {
std::cout << 'Nilai:' << std::any_cast < berganda > ( nilai ) << std::endl;
} lain jika ( jenis nilai ( ) == ditaip ( std::rentetan ) ) {
std::cout << 'Nilai:' << std::any_cast < std::rentetan > ( nilai ) << std::endl;
} lain {
std::cout << 'Jenis tidak disokong!' << std::endl;
}
} lain {
std::cout << 'Tiada nilai disimpan dalam std::any.' << std::endl;
}
}
int utama ( ) {
prosesAny ( 42 ) ;
prosesAny ( 3.14 ) ;
prosesAny ( std::rentetan ( 'Hello, std::mana-mana!' ) ) ;
prosesAny ( 4.5f ) ; // Tidak disokong menaip
kembali 0 ;
}
Dalam contoh ini, kami mentakrifkan fungsi 'processAny' yang mengambil rujukan 'std:: any' sebagai parameter dan memeriksa kandungannya. Di dalam fungsi, kami mula-mula menyemak sama ada pembolehubah 'std:: any' mempunyai nilai yang disimpan menggunakan has_value(). Jika nilai ada, kami menentukan jenis nilai yang disimpan menggunakan type().name() dan teruskan mencetak nilai yang sepadan berdasarkan jenisnya. Fungsi utama kemudiannya menunjukkan utiliti 'processAny' dengan memanggilnya dengan jenis yang berbeza: integer (42), double (3.14), dan rentetan ('Hello, std:: any!'). Fungsi ini mengendalikan setiap jenis dan mencetak nilai masing-masing dengan sewajarnya. Walau bagaimanapun, apabila cuba memproses nombor titik terapung (4.5f), yang tidak disokong dalam contoh ini, program ini mengendalikan keadaan dengan baik dengan menunjukkan bahawa jenis itu tidak disokong.
Output yang dihasilkan ialah:
Ini mempamerkan cara 'std::any' membolehkan pengendalian dinamik pelbagai jenis data, menjadikannya alat serba boleh untuk pengaturcaraan generik dalam C++.
Contoh 2: Menyimpan Jenis Ditentukan Pengguna
Contoh kedua meneroka cara jenis dinamik ini dalam Perpustakaan Templat Standard (STL) dengan lancar menampung struktur data tersuai. Dengan memfokuskan pada jenis yang ditentukan pengguna, struktur titik, kami mempamerkan cara 'std::any' mengendalikan kejadian struktur tersebut.
Inilah kodnya:
#include#include
kelas MyClass {
awam:
Kelas saya ( nilai int ) : data ( nilai ) { }
void printData ( ) const {
std::cout << 'Data dalam MyClass: ' << data << std::endl;
}
peribadi:
data int;
} ;
int utama ( ) {
std::any anyObject = MyClass ( 42 ) ;
jika ( anyObject.has_value ( ) ) {
auto & myClassInstance = std::any_cast < Kelas saya &> ( anyObject ) ;
myClassInstance.printData ( ) ;
} lain {
std::cout << 'Tiada nilai disimpan dalam std::any.' << std::endl;
}
kembali 0 ;
}
Dalam coretan kod C++ ini, kami mencipta contoh mudah untuk menggambarkan menggunakan jenis 'std::any' dengan kelas yang ditentukan pengguna yang dipanggil 'MyClass'. Dalam kelas, terdapat pembolehubah ahli persendirian yang dipanggil 'data' dan kaedah awam yang dipanggil printData() untuk memaparkan nilai data ini. Nilai integer diluluskan dan diberikan kepada ahli 'data' dalam pembina.
Dalam fungsi 'utama', kami membuat instantiat objek 'MyClass' dengan nilai awal 42 dan kemudian menyimpannya dalam pembolehubah 'std::any' bernama 'anyObject'. Ini menunjukkan keupayaan 'std::any' untuk memegang contoh kelas yang ditentukan pengguna.
Berikutan ini, kami menggunakan pernyataan 'jika' untuk menyemak sama ada 'anyObject' mempunyai nilai menggunakan kaedah has_value(). Jika terdapat nilai, kami mendapatkan semula objek yang disimpan menggunakan 'std::any_cast'. 'std::any_cast' digunakan dengan argumen templat 'MyClass&' untuk menghantar objek yang disimpan ke rujukan 'MyClass'. Rujukan ini, 'myClassInstance', kemudiannya digunakan untuk memanggil kaedah printData(), mempamerkan keupayaan untuk mengakses dan beroperasi pada jenis yang ditakrifkan pengguna yang disimpan dalam 'std::any'.
Jika tiada nilai disimpan dalam 'std:: any', kami mencetak mesej yang menandakan ini. Semakan bersyarat ini memastikan bahawa kami mengendalikan senario di mana pembolehubah 'std:: any' mungkin kosong.
Berikut adalah outputnya:
Contoh 3: Bekas Jenis Campuran
Dalam pengaturcaraan, 'bekas jenis campuran' merujuk kepada struktur data yang mampu menyimpan elemen pelbagai jenis data yang mungkin tidak berkaitan. Fleksibiliti ini berharga apabila berurusan dengan senario di mana jenis data tidak diketahui pada masa penyusunan atau berubah secara dinamik semasa pelaksanaan program. Dalam C++, 'std::any' mencontohkan konsep ini, membenarkan penciptaan satu bekas untuk menyimpan nilai jenis yang berbeza.
Mari kita terokai senario di mana kita mencipta bekas yang mengandungi pelbagai jenis:
#include#include
#include
int utama ( ) {
std::vektor < std::mana-mana > bekas bercampur;
mixedContainer.push_back ( 42 ) ;
mixedContainer.push_back ( 3.14 ) ;
mixedContainer.push_back ( std::rentetan ( 'Hello' ) ) ;
mixedContainer.push_back ( benar ) ;
untuk ( const auto & elemen: campuranBekas ) {
jika ( unsur.jenis ( ) == ditaip ( int ) ) {
std::cout << 'Integer:' << std::any_cast < int > ( unsur ) << std::endl;
} lain jika ( unsur.jenis ( ) == ditaip ( berganda ) ) {
std::cout << 'Double:' << std::any_cast < berganda > ( unsur ) << std::endl;
} lain jika ( unsur.jenis ( ) == ditaip ( std::rentetan ) ) {
std::cout << 'Tali: ' << std::any_cast < std::rentetan > ( unsur ) << std::endl;
} lain jika ( unsur.jenis ( ) == ditaip ( bool ) ) {
std::cout << 'Boolean:' << std::any_cast < bool > ( unsur ) << std::endl;
} lain {
std::cout << 'Jenis tidak diketahui' << std::endl;
}
}
kembali 0 ;
}
Dalam ilustrasi ini, kami menunjukkan konsep bekas jenis campuran menggunakan C++ dan ciri 'std::any'. Kami mencipta 'std::vector
Semasa kami mengulangi 'mixedContainer' menggunakan gelung 'untuk', kami menggunakan fungsi type() untuk mengenal pasti jenis data setiap elemen secara dinamik. Menggunakan 'std::any_cast', kami mengekstrak dan mencetak nilai yang sepadan berdasarkan jenisnya. Sebagai contoh, jika elemen jenis 'int', kami mencetaknya sebagai integer. Jika jenis 'double', kami mencetaknya sebagai double, dan seterusnya.
Berikut ialah output yang dihasilkan:
Contoh 4: Ralat Pengendalian dengan Std:: Mana-mana
Mengendalikan ralat apabila menggunakan 'std::any' melibatkan pemeriksaan sama ada jenis itu disokong atau sama ada nilai disimpan. Dalam contoh ini, kami menunjukkan cara mengendalikan jenis yang tidak disokong:
#include#include
int utama ( ) {
std::any myAny = 42 ;
cubalah {
nilai berganda = std::any_cast < berganda > ( myAny ) ;
std::cout << 'Nilai:' << nilai << std::endl;
} tangkap ( const std::bad_any_cast & Ia adalah ) {
std::cerr << 'Ralat:' << e.apa ( ) << std::endl;
}
kembali 0 ;
}
Kita mulakan dengan memulakan pembolehubah 'std::any', 'myAny', dengan nilai 42 jenis integer. Di dalam blok 'cuba' seterusnya, kami membuat percubaan eksplisit untuk menghantar nilai integer ini menjadi 'berganda' menggunakan operasi 'std::any_cast
Untuk menguruskan ralat yang berpotensi ini dengan anggun, kami melaksanakan pengendalian pengecualian dengan blok 'tangkapan' yang direka bentuk untuk menangkap jenis pengecualian khusus 'std::bad_any_cast'. Sekiranya hantaran tidak berjaya, blok 'tangkapan' diaktifkan dan kami menjana mesej ralat menggunakan 'std::cerr' untuk menyampaikan sifat ralat. Strategi pengendalian ralat ini memastikan program kami dapat mengendalikan situasi di mana jenis cubaan itu bertembung dengan jenis sebenar yang disimpan dalam pembolehubah 'std::any'.
Kesimpulan
Dalam artikel ini, kami meneroka aplikasi 'std::any' dalam C++, bekas jenis dinamik yang diperkenalkan dalam C++ untuk nilai pelbagai jenis. Kami menunjukkan kepelbagaiannya melalui pelbagai contoh, mempamerkan senario yang terdiri daripada penggunaan asas kepada pengendalian jenis yang ditentukan pengguna dan koleksi heterogen. Kami menunjukkan aplikasi praktikalnya dalam senario di mana jenis data tidak diketahui pada masa penyusunan. Selain itu, kami meneroka tentang teknik pengendalian ralat, menekankan kepentingan mengurus jenis yang tidak disokong secara anggun melalui pengendalian pengecualian.