C++ programmēšanā “std::any” no standarta veidņu bibliotēkas (STL) ievieš dinamisku rakstīšanu, lai apstrādātu neviendabīgus datus. Atšķirībā no tradicionālajiem konteineriem, “std::any” ļauj saglabāt jebkura veida vērtības vienā konteinerā, palielinot elastību scenārijos, kad datu tipi nav zināmi vai atšķiras izpildes laikā. Šī tipa agnostiskā pieeja veicina vispārēju programmēšanu, kas dod iespēju izstrādātājiem izveidot pielāgojamāku un izteiksmīgāku kodu, vienlaikus saglabājot tipa drošību. Šajā izpētē mēs iedziļināsimies “std::any” funkcijās, tā lietošanas modeļos un praktiskos piemēros, kas ilustrē tā lomu stabila un elastīga C++ koda rakstīšanā.
1. piemērs: standarta Std::Any izmantošana
Vispirms izpētīsim vienkāršu piemēru, lai parādītu “std::any” pamata lietojumu. Apsveriet scenāriju, kurā jums ir nepieciešama funkcija, lai pieņemtu dažāda veida parametrus:
Šeit ir koda fragments:
#include
#include
nederīgs process Jebkurš ( const std::any & vērtību ) {
ja ( vērtība.ir_vērtība ( ) ) {
std::cout << 'Saglabātās vērtības veids:' << value.type ( ) .nosaukums ( ) << std::endl;
ja ( value.type ( ) == drukāts ( starpt ) ) {
std::cout << 'Vērtība:' << std::any_cast < starpt > ( vērtību ) << std::endl;
} cits ja ( value.type ( ) == drukāts ( dubultā ) ) {
std::cout << 'Vērtība:' << std::any_cast < dubultā > ( vērtību ) << std::endl;
} cits ja ( value.type ( ) == drukāts ( std::string ) ) {
std::cout << 'Vērtība:' << std::any_cast < std::string > ( vērtību ) << std::endl;
} cits {
std::cout << 'Neatbalstīts veids!' << std::endl;
}
} cits {
std::cout << 'Std::any nav saglabāta neviena vērtība.' << std::endl;
}
}
int galvenais ( ) {
process Jebkurš ( 42 ) ;
process Jebkurš ( 3.14 ) ;
process Jebkurš ( std::string ( 'Sveiki, std::any!' ) ) ;
process Jebkurš ( 4.5f ) ; // Neatbalstīts veids
atgriezties 0 ;
}
Šajā piemērā mēs definējam funkciju “processAny”, kas kā parametru izmanto atsauci “std::any” un pārbauda tās saturu. Funkcijā vispirms pārbaudām, vai mainīgajam “std::any” ir saglabāta vērtība, izmantojot has_value (). Ja vērtība ir klāt, mēs nosakām saglabātās vērtības veidu, izmantojot type().name() un turpinām drukāt atbilstošo vērtību, pamatojoties uz tās veidu. Pēc tam galvenā funkcija parāda “processAny” lietderību, izsaucot to ar dažādiem veidiem: vesels skaitlis (42), dubults (3.14) un virkne (“Hello, std::any!”). Funkcija atbilstoši apstrādā katru veidu un izdrukā attiecīgās vērtības. Tomēr, mēģinot apstrādāt peldošā komata skaitli (4.5f), kas šajā piemērā netiek atbalstīts, programma graciozi risina situāciju, norādot, ka veids netiek atbalstīts.
Ģenerētā izvade ir:
Tas parāda, kā “std::any” nodrošina dažādu datu tipu dinamisku apstrādi, padarot to par daudzpusīgu rīku vispārīgai programmēšanai C++.
2. piemērs. Lietotāja definēto veidu saglabāšana
Otrajā piemērā tiek pētīts, kā šis dinamiskais tips standarta veidņu bibliotēkā (STL) nemanāmi pielāgojas pielāgotajām datu struktūrām. Koncentrējoties uz lietotāja definētu tipu, punktu struktūru, mēs parādām, kā “std::any” apstrādā šādu struktūru gadījumus.
Šeit ir kods:
#include#include
klase MyClass {
publiski:
Mana klase ( int vērtība ) : dati ( vērtību ) { }
nederīgi drukas dati ( ) konst {
std::cout << 'Dati in MyClass:' << datus << std::endl;
}
Privāts:
int dati;
} ;
int galvenais ( ) {
std::any anyObject = MyClass ( 42 ) ;
ja ( anyObject.has_value ( ) ) {
auto & myClassInstance = std::any_cast < Mana klase &> ( jebkurš objekts ) ;
myClassInstance.printData ( ) ;
} cits {
std::cout << 'Std::any nav saglabāta neviena vērtība.' << std::endl;
}
atgriezties 0 ;
}
Šajā C++ koda fragmentā mēs izveidojam vienkāršu piemēru, lai ilustrētu, izmantojot veidu “std::any” ar lietotāja definētu klasi ar nosaukumu “MyClass”. Klasē ir privāts dalībnieka mainīgais ar nosaukumu “data” un publiska metode printData(), lai parādītu šo datu vērtību. Vesela skaitļa vērtība tiek nodota un piešķirta konstruktorā “datu” dalībniekam.
Funkcijā “galvenā” mēs izveidojam “MyClass” objektu ar sākotnējo vērtību 42 un pēc tam saglabājam to mainīgajā “std::any” ar nosaukumu “anyObject”. Tas parāda “std::any” spēju turēt lietotāja definētu klašu gadījumus.
Pēc tam mēs izmantojam paziņojumu “if”, lai pārbaudītu, vai “anyObject” ir vērtība, izmantojot metodi has_value(). Ja ir vērtība, mēs izgūstam saglabāto objektu, izmantojot “std::any_cast”. “std::any_cast” tiek izmantots kopā ar veidnes argumentu “MyClass&”, lai saglabāto objektu novirzītu uz “MyClass” atsauci. Pēc tam šī atsauce “myClassInstance” tiek izmantota, lai izsauktu metodi printData(), parādot iespēju piekļūt saglabātajam lietotāja definētajam tipam un darboties ar to “std::any” ietvaros.
Ja laukā “std::any” nav saglabāta neviena vērtība, mēs izdrukājam ziņojumu, kas to norāda. Šī nosacījuma pārbaude nodrošina, ka tiek apstrādāti scenāriji, kuros mainīgais “std::any” var būt tukšs.
Šeit ir izvade:
3. piemērs: jaukta tipa konteiners
Programmēšanā 'jaukta tipa konteiners' attiecas uz datu struktūru, kas spēj saturēt dažādu, potenciāli nesaistītu datu tipu elementus. Šī elastība ir vērtīga, strādājot ar scenārijiem, kuros datu tipi nav zināmi kompilēšanas laikā vai dinamiski mainās programmas izpildes laikā. C++ valodā “std::any” ir šīs koncepcijas piemērs, ļaujot izveidot vienu konteineru dažādu veidu vērtību glabāšanai.
Izpētīsim scenāriju, kurā mēs izveidojam konteineru, kurā ir dažādi veidi:
#include#include
#iekļaut
int galvenais ( ) {
std::vektors < std::jebkurš > jaukts konteiners;
mixContainer.push_back ( 42 ) ;
mixContainer.push_back ( 3.14 ) ;
mixContainer.push_back ( std::string ( 'Sveiki' ) ) ;
mixContainer.push_back ( taisnība ) ;
priekš ( const auto & elements : mixContainer ) {
ja ( elements.type ( ) == drukāts ( starpt ) ) {
std::cout << 'Vesels skaitlis: ' << std::any_cast < starpt > ( elements ) << std::endl;
} cits ja ( elements.type ( ) == drukāts ( dubultā ) ) {
std::cout << 'Dubults:' << std::any_cast < dubultā > ( elements ) << std::endl;
} cits ja ( elements.type ( ) == drukāts ( std::string ) ) {
std::cout << 'String:' << std::any_cast < std::string > ( elements ) << std::endl;
} cits ja ( elements.type ( ) == drukāts ( bool ) ) {
std::cout << 'Būla:' << std::any_cast < bool > ( elements ) << std::endl;
} cits {
std::cout << 'Nezināms veids' << std::endl;
}
}
atgriezties 0 ;
}
Šajā ilustrācijā mēs demonstrējam jaukta tipa konteinera koncepciju, izmantojot C++ un funkciju “std::any”. Mēs izveidojam “std::vector
Pārejot cauri “mixedContainer”, izmantojot cilpu “for”, mēs izmantojam type() funkciju, lai dinamiski identificētu katra elementa datu tipu. Izmantojot “std::any_cast”, mēs iegūstam un izdrukājam atbilstošās vērtības, pamatojoties uz to veidiem. Piemēram, ja elementa tips ir “int”, mēs to izdrukājam kā veselu skaitli. Ja tas ir “dubults”, mēs to izdrukājam kā dubultu un tā tālāk.
Šeit ir ģenerētā izvade:
4. piemērs. Kļūdu apstrāde ar Std::Any
Kļūdu apstrāde, izmantojot “std::any”, ietver pārbaudi, vai veids tiek atbalstīts un vai ir saglabāta vērtība. Šajā piemērā mēs parādām, kā rīkoties ar neatbalstītajiem veidiem:
#include#include
int galvenais ( ) {
std::any myAny = 42 ;
mēģināt {
dubultā vērtība = std::any_cast < dubultā > ( mans Jebkurš ) ;
std::cout << 'Vērtība:' << vērtību << std::endl;
} noķert ( const std::bad_any_cast & Tas ir ) {
std::cerr << 'Kļūda:' << e.kas ( ) << std::endl;
}
atgriezties 0 ;
}
Mēs sākam ar mainīgā “std::any” inicializāciju “myAny” ar vesela skaitļa vērtību 42. Nākamajā blokā “try” mēs veicam skaidru mēģinājumu nodot šo veselo skaitļa vērtību “double”, izmantojot operāciju “std::any_cast
Lai graciozi pārvaldītu šo potenciālo kļūdu, mēs ieviešam izņēmumu apstrādi ar “catch” bloku, kas ir paredzēts, lai uztvertu konkrēto izņēmuma veidu “std::bad_any_cast”. Neveiksmīgas apraides gadījumā tiek aktivizēts bloks “catch”, un mēs ģenerējam kļūdas ziņojumu, izmantojot “std::cerr”, lai paziņotu par kļūdas būtību. Šī kļūdu apstrādes stratēģija nodrošina, ka mūsu programma var graciozi rīkoties situācijās, kad mēģinātā tipa apraide ir pretrunā faktiskajam tipam, kas tiek saglabāts mainīgajā “std::any”.
Secinājums
Šajā rakstā mēs izpētījām “std::any” lietojumus C++ — dinamiska tipa konteinerā, kas tiek ieviests C++ dažādu veidu vērtībām. Mēs demonstrējām tā daudzpusību, izmantojot dažādus piemērus, parādot scenārijus, sākot no pamata lietojuma līdz lietotāja definētu veidu un neviendabīgu kolekciju apstrādei. Mēs demonstrējām tā praktisko pielietojumu scenārijos, kuros datu veids nav zināms kompilēšanas laikā. Turklāt mēs izpētījām kļūdu apstrādes metodes, uzsverot, cik svarīgi ir graciozi pārvaldīt neatbalstītos veidus, izmantojot izņēmumu apstrādi.