Dalam pemrograman C++, “std::any” dari Standard Template Library (STL) memperkenalkan pengetikan dinamis untuk menangani data heterogen. Tidak seperti container tradisional, “std::any” memungkinkan penyimpanan nilai jenis apa pun dalam satu container, meningkatkan fleksibilitas dalam skenario di mana tipe data tidak diketahui atau bervariasi pada waktu proses. Pendekatan tipe-agnostik ini mempromosikan pemrograman generik yang memberdayakan pengembang untuk membuat kode yang lebih mudah beradaptasi dan ekspresif dengan tetap menjaga keamanan tipe. Dalam eksplorasi ini, kita akan mempelajari fitur “std::any”, pola penggunaannya, dan contoh praktis yang menggambarkan perannya dalam menulis kode C++ yang kuat dan fleksibel.
Contoh 1: Penggunaan Dasar Std::Any
Pertama, mari kita jelajahi contoh langsung untuk mendemonstrasikan penggunaan dasar “std::any”. Pertimbangkan skenario di mana Anda memerlukan suatu fungsi untuk menerima berbagai jenis parameter:
Berikut cuplikan kodenya:
#termasuk
#sertakan
proses batalApa pun ( const std::apa saja & nilai ) {
jika ( nilai.has_value ( ) ) {
std::cout << 'Jenis nilai yang disimpan:' << nilai.tipe ( ) .nama ( ) << std::endl;
jika ( nilai.tipe ( ) == mengetik ( ke dalam ) ) {
std::cout << 'Nilai: ' << std::any_cast < ke dalam > ( nilai ) << std::endl;
} kalau tidak jika ( nilai.tipe ( ) == mengetik ( dobel ) ) {
std::cout << 'Nilai: ' << std::any_cast < dobel > ( nilai ) << std::endl;
} kalau tidak jika ( nilai.tipe ( ) == mengetik ( std::string ) ) {
std::cout << 'Nilai: ' << std::any_cast < std::string > ( nilai ) << std::endl;
} kalau tidak {
std::cout << 'Tipe tidak didukung!' << std::endl;
}
} kalau tidak {
std::cout << 'Tidak ada nilai yang disimpan di std::any.' << std::endl;
}
}
ke utama ( ) {
prosesAny ( 42 ) ;
prosesAny ( 3.14 ) ;
prosesAny ( std::string ( 'Halo, std::apa saja!' ) ) ;
prosesAny ( 4.5f ) ; // Tidak didukung jenis
kembali 0 ;
}
Dalam contoh ini, kita mendefinisikan fungsi “processAny” yang mengambil referensi “std::any” sebagai parameter dan memeriksa kontennya. Di dalam fungsi, pertama-tama kita memeriksa apakah variabel “std::any” memiliki nilai yang disimpan menggunakan has_value(). Jika ada nilai, kita menentukan tipe nilai yang disimpan menggunakan type().name() dan melanjutkan untuk mencetak nilai terkait berdasarkan tipenya. Fungsi utama kemudian mendemonstrasikan kegunaan 'processAny' dengan memanggilnya dengan tipe berbeda: integer (42), double (3.14), dan string ('Halo, std::any!'). Fungsi ini menangani setiap jenis dengan tepat dan mencetak nilainya masing-masing. Namun, ketika mencoba memproses angka floating-point (4.5f), yang tidak didukung dalam contoh ini, program menangani situasi tersebut dengan baik dengan menunjukkan bahwa tipe tersebut tidak didukung.
Keluaran yang dihasilkan adalah:
Ini menunjukkan bagaimana “std::any” memungkinkan penanganan dinamis berbagai tipe data, menjadikannya alat serbaguna untuk pemrograman generik di C++.
Contoh 2: Menyimpan Tipe Buatan Pengguna
Contoh kedua mengeksplorasi bagaimana tipe dinamis dalam Standard Template Library (STL) mengakomodasi struktur data kustom dengan lancar. Berfokus pada tipe yang ditentukan pengguna, struktur titik, kami menunjukkan bagaimana “std::any” menangani instance struktur tersebut.
Ini kodenya:
#termasuk#sertakan
kelas Kelasku {
publik:
Kelasku ( nilai int ) : data ( nilai ) { }
batalkan data cetak ( ) konstanta {
std::cout << 'Data di Kelasku:' << data << std::endl;
}
pribadi:
ke dalam data;
} ;
ke utama ( ) {
std::any anyObject = Kelas Saya ( 42 ) ;
jika ( anyObject.has_value ( ) ) {
mobil & myClassInstance = std::any_cast < Kelasku &> ( objek apa pun ) ;
myClassInstance.printData ( ) ;
} kalau tidak {
std::cout << 'Tidak ada nilai yang disimpan di std::any.' << std::endl;
}
kembali 0 ;
}
Dalam cuplikan kode C++ ini, kami membuat contoh sederhana untuk mengilustrasikan penggunaan tipe “std::any” dengan kelas yang ditentukan pengguna yang disebut “MyClass”. Di dalam kelas, terdapat variabel anggota privat yang disebut “data” dan metode publik yang disebut printData() untuk menampilkan nilai data ini. Nilai integer diteruskan dan ditetapkan ke anggota “data” di konstruktor.
Dalam fungsi “main”, kita membuat instance objek “MyClass” dengan nilai awal 42 dan kemudian menyimpannya dalam variabel “std::any” bernama “anyObject”. Ini menunjukkan kemampuan “std::any” untuk menampung instance kelas yang ditentukan pengguna.
Setelah ini, kita menggunakan pernyataan “if” untuk memeriksa apakah “anyObject” memiliki nilai menggunakan metode has_value(). Jika ada nilai, kita mengambil objek yang disimpan menggunakan “std::any_cast”. 'std::any_cast' digunakan dengan argumen template 'MyClass&' untuk melemparkan objek yang disimpan ke referensi 'MyClass'. Referensi ini, “myClassInstance”, kemudian digunakan untuk memanggil metode printData(), menampilkan kemampuan untuk mengakses dan mengoperasikan tipe tersimpan yang ditentukan pengguna dalam “std::any”.
Jika tidak ada nilai yang disimpan di “std::any”, kami mencetak pesan yang menandakan ini. Pemeriksaan bersyarat ini memastikan bahwa kami menangani skenario di mana variabel “std::any” mungkin kosong.
Inilah hasilnya:
Contoh 3: Wadah Tipe Campuran
Dalam pemrograman, “wadah tipe campuran” mengacu pada struktur data yang mampu menampung elemen tipe data yang beragam dan mungkin tidak terkait. Fleksibilitas ini berharga ketika berhadapan dengan skenario dimana tipe data tidak diketahui pada waktu kompilasi atau berubah secara dinamis selama eksekusi program. Dalam C++, “std::any” mencontohkan konsep ini, memungkinkan pembuatan satu container untuk menyimpan nilai dari tipe yang berbeda.
Mari kita jelajahi skenario saat kita membuat container yang menampung berbagai jenis:
#termasuk#sertakan
#termasuk
ke utama ( ) {
std::vektor < std::apa saja > wadah campuran;
mixedContainer.push_back ( 42 ) ;
mixedContainer.push_back ( 3.14 ) ;
mixedContainer.push_back ( std::string ( 'Halo' ) ) ;
mixedContainer.push_back ( BENAR ) ;
untuk ( konstanta otomatis & elemen : wadah campuran ) {
jika ( elemen.tipe ( ) == mengetik ( ke dalam ) ) {
std::cout << 'Bilangan bulat:' << std::any_cast < ke dalam > ( elemen ) << std::endl;
} kalau tidak jika ( elemen.tipe ( ) == mengetik ( dobel ) ) {
std::cout << 'Dobel: ' << std::any_cast < dobel > ( elemen ) << std::endl;
} kalau tidak jika ( elemen.tipe ( ) == mengetik ( std::string ) ) {
std::cout << 'Rangkaian: ' << std::any_cast < std::string > ( elemen ) << std::endl;
} kalau tidak jika ( elemen.tipe ( ) == mengetik ( bodoh ) ) {
std::cout << 'Boolean:' << std::any_cast < bodoh > ( elemen ) << std::endl;
} kalau tidak {
std::cout << 'Tipe tidak dikenal' << std::endl;
}
}
kembali 0 ;
}
Dalam ilustrasi ini, kami mendemonstrasikan konsep container tipe campuran menggunakan C++ dan fitur “std::any”. Kami membuat 'std::vector
Saat kami melakukan iterasi melalui “mixedContainer” menggunakan loop “for”, kami menggunakan fungsi type() untuk mengidentifikasi tipe data setiap elemen secara dinamis. Memanfaatkan “std::any_cast”, kami mengekstrak dan mencetak nilai yang sesuai berdasarkan tipenya. Misalnya, jika elemen bertipe “int”, kami mencetaknya sebagai bilangan bulat. Kalau bertipe “double”, kita cetak double, dan seterusnya.
Berikut adalah output yang dihasilkan:
Contoh 4: Penanganan Kesalahan dengan Std::Any
Menangani kesalahan saat menggunakan “std::any” melibatkan pemeriksaan apakah tipe tersebut didukung atau apakah suatu nilai disimpan. Dalam contoh ini, kami menunjukkan cara menangani tipe yang tidak didukung:
#termasuk#sertakan
ke utama ( ) {
std::any myAny = 42 ;
mencoba {
nilai ganda = std::any_cast < dobel > ( milikku ) ;
std::cout << 'Nilai: ' << nilai << std::endl;
} menangkap ( const std::bad_any_cast & Dia ) {
std::cerr << 'Kesalahan:' << e.apa ( ) << std::endl;
}
kembali 0 ;
}
Kita mulai dengan menginisialisasi variabel “std::any”, “myAny”, dengan nilai 42 bertipe integer. Di dalam blok “coba” berikutnya, kami melakukan upaya eksplisit untuk memasukkan nilai integer ini ke dalam “ganda” menggunakan operasi “std::any_cast
Untuk mengelola potensi kesalahan ini dengan baik, kami menerapkan penanganan pengecualian dengan blok “catch” yang dirancang untuk menangkap jenis pengecualian spesifik “std::bad_any_cast”. Jika cast gagal, blok “catch” diaktifkan dan kami menghasilkan pesan kesalahan menggunakan “std::cerr” untuk menyampaikan sifat kesalahannya. Strategi penanganan kesalahan ini memastikan bahwa program kami dapat dengan baik menangani situasi di mana tipe yang dicoba bertabrakan dengan tipe sebenarnya yang disimpan dalam variabel “std::any”.
Kesimpulan
Dalam artikel ini, kita menjelajahi penerapan “std::any” di C++, sebuah container tipe dinamis yang diperkenalkan di C++ untuk nilai dengan tipe yang beragam. Kami mendemonstrasikan keserbagunaannya melalui berbagai contoh, menampilkan skenario mulai dari penggunaan dasar hingga menangani tipe yang ditentukan pengguna dan koleksi heterogen. Kami mendemonstrasikan penerapan praktisnya dalam skenario di mana tipe data tidak diketahui pada waktu kompilasi. Selain itu, kami mempelajari tentang teknik penanganan kesalahan, menekankan pentingnya mengelola jenis yang tidak didukung dengan baik melalui penanganan pengecualian.