Programuojant C++, „std::any“ iš standartinės šablonų bibliotekos (STL) įveda dinaminį rašymą, kad būtų galima apdoroti nevienalyčius duomenis. Skirtingai nuo tradicinių konteinerių, „std::any“ leidžia saugoti bet kokio tipo reikšmes viename konteineryje, padidindama lankstumą scenarijuose, kai duomenų tipai nežinomi arba skiriasi vykdymo metu. Šis tipo agnostinis metodas skatina bendrą programavimą, kuris įgalina kūrėjus sukurti labiau pritaikomą ir išraiškingesnį kodą išlaikant tipo saugumą. Šiame tyrime mes gilinsimės į „std::any“ ypatybes, jo naudojimo modelius ir praktinius pavyzdžius, iliustruojančius jo vaidmenį rašant tvirtą ir lankstų C++ kodą.
1 pavyzdys: Pagrindinis Std::Any naudojimas
Pirmiausia panagrinėkime paprastą pavyzdį, kad parodytume pagrindinį „std::any“ naudojimą. Apsvarstykite scenarijų, kai jums reikia funkcijos įvairių tipų parametrams priimti:
Štai kodo fragmentas:
#include
#include
negaliojantis procesas Bet koks ( const std::any & vertė ) {
jeigu ( value.has_value ( ) ) {
std::cout << „Išsaugotos vertės tipas:“ << value.type ( ) .vardas ( ) << std::endl;
jeigu ( value.type ( ) == tipo ( tarpt ) ) {
std::cout << 'Vertė:' << std::any_cast < tarpt > ( vertė ) << std::endl;
} Kitas jeigu ( value.type ( ) == tipo ( dvigubai ) ) {
std::cout << 'Vertė:' << std::any_cast < dvigubai > ( vertė ) << std::endl;
} Kitas jeigu ( value.type ( ) == tipo ( std::string ) ) {
std::cout << 'Vertė:' << std::any_cast < std::string > ( vertė ) << std::endl;
} Kitas {
std::cout << 'Nepalaikomas tipas!' << std::endl;
}
} Kitas {
std::cout << 'Std::any nėra saugomos jokios reikšmės.' << std::endl;
}
}
tarp pagrindinis ( ) {
procesas Bet koks ( 42 ) ;
procesas Bet koks ( 3.14 ) ;
procesas Bet koks ( std::string ( 'Sveiki, std::any!' ) ) ;
procesas Bet koks ( 4.5f ) ; // Nepalaikoma tipo
grąžinti 0 ;
}
Šiame pavyzdyje apibrėžiame funkciją „processAny“, kuri kaip parametrą priima nuorodą „std::any“ ir tiria jos turinį. Funkcijoje pirmiausia patikriname, ar kintamasis „std::any“ turi išsaugotą reikšmę naudojant has_value (). Jei reikšmė yra, mes nustatome saugomos vertės tipą naudodami type().name() ir pradedame spausdinti atitinkamą vertę pagal jos tipą. Tada pagrindinė funkcija parodo „processAny“ naudingumą, vadindama jį skirtingais tipais: sveikuoju skaičiumi (42), dvigubu (3.14) ir eilute („Hello, std::any!“). Funkcija tinkamai tvarko kiekvieną tipą ir išspausdina atitinkamas reikšmes. Tačiau bandant apdoroti slankiojo kablelio skaičių (4.5f), kuris šiame pavyzdyje nepalaikomas, programa dailiai susidoroja su situacija, nurodydama, kad tipas nepalaikomas.
Sugeneruota išvestis yra tokia:
Tai parodo, kaip „std::any“ leidžia dinamiškai tvarkyti įvairius duomenų tipus, todėl tai yra universalus įrankis bendram programavimui C++.
2 pavyzdys: vartotojo nustatytų tipų saugojimas
Antrame pavyzdyje nagrinėjama, kaip šis dinaminis tipas standartinėje šablonų bibliotekoje (STL) sklandžiai prisitaiko prie tinkintų duomenų struktūrų. Sutelkdami dėmesį į vartotojo apibrėžtą tipą, taškų struktūrą, parodome, kaip „std::any“ tvarko tokių struktūrų atvejus.
Štai kodas:
#include#include
klasė MyClass {
vieša:
Mano klasė ( int vertė ) : duomenys ( vertė ) { }
negalioja spausdinimo duomenys ( ) konst {
std::cout << „Data in MyClass:“ << duomenis << std::endl;
}
privatus:
int duomenys;
} ;
tarp pagrindinis ( ) {
std::any anyObject = MyClass ( 42 ) ;
jeigu ( anyObject.has_value ( ) ) {
automatinis & myClassInstance = std::any_cast < Mano klasė &> ( bet koks objektas ) ;
myClassInstance.printData ( ) ;
} Kitas {
std::cout << 'Std::any nėra saugomos jokios reikšmės.' << std::endl;
}
grąžinti 0 ;
}
Šiame C++ kodo fragmente sukuriame paprastą pavyzdį, skirtą iliustruoti naudojant tipą „std::any“ su vartotojo apibrėžta klase, pavadinta „MyClass“. Klasėje yra privatus nario kintamasis, vadinamas „data“, ir viešasis metodas, vadinamas printData(), kad būtų rodoma šių duomenų vertė. Sveikasis skaičius perduodamas ir priskiriamas konstruktoriaus „duomenų“ nariui.
„Pagrindinėje“ funkcijoje mes sukuriame „MyClass“ objektą, kurio pradinė vertė yra 42, ir išsaugome jį „std::any“ kintamajame, pavadintame „anyObject“. Tai parodo „std::any“ galimybę laikyti vartotojo apibrėžtų klasių egzempliorius.
Po to naudojame teiginį „if“, kad patikrintume, ar „anyObject“ turi reikšmę, naudodami metodą has_value(). Jei yra reikšmė, mes gauname saugomą objektą naudodami „std::any_cast“. „std::any_cast“ naudojamas su „MyClass&“ šablono argumentu, kad saugomas objektas būtų nukreiptas į „MyClass“ nuorodą. Ši nuoroda „myClassInstance“ naudojama iškviesti metodą printData(), parodantį galimybę pasiekti saugomą vartotojo apibrėžtą tipą ir naudoti jį naudojant „std::any“.
Jei „std::any“ nėra saugoma jokios reikšmės, išspausdiname tai reiškiantį pranešimą. Šis sąlyginis patikrinimas užtikrina, kad tvarkome scenarijus, kai kintamasis „std::any“ gali būti tuščias.
Štai išvestis:
3 pavyzdys: mišrių tipų konteineris
Programuojant „mišraus tipo konteineris“ reiškia duomenų struktūrą, galinčią laikyti įvairių, galimai nesusijusių duomenų tipų elementus. Šis lankstumas yra vertingas sprendžiant scenarijus, kai duomenų tipai nežinomi kompiliavimo metu arba dinamiškai keičiasi programos vykdymo metu. C++ kalboje „std::any“ yra šios koncepcijos pavyzdys, leidžiantis sukurti vieną konteinerį, kuriame būtų saugomos skirtingų tipų reikšmės.
Išnagrinėkime scenarijų, kai kuriame konteinerį, kuriame yra įvairių tipų:
#include#include
#įtraukti
tarp pagrindinis ( ) {
std::vektorius < std::bet koks > mišrus konteineris;
mixContainer.push_back ( 42 ) ;
mixContainer.push_back ( 3.14 ) ;
mixContainer.push_back ( std::string ( 'Sveiki' ) ) ;
mixContainer.push_back ( tiesa ) ;
dėl ( const auto & elementas: mixContainer ) {
jeigu ( elementas.tipas ( ) == tipo ( tarpt ) ) {
std::cout << 'Sveikasis skaičius:' << std::any_cast < tarpt > ( elementas ) << std::endl;
} Kitas jeigu ( elementas.tipas ( ) == tipo ( dvigubai ) ) {
std::cout << 'Dvigubas:' << std::any_cast < dvigubai > ( elementas ) << std::endl;
} Kitas jeigu ( elementas.tipas ( ) == tipo ( std::string ) ) {
std::cout << 'Styga:' << std::any_cast < std::string > ( elementas ) << std::endl;
} Kitas jeigu ( elementas.tipas ( ) == tipo ( bool ) ) {
std::cout << 'Boolean:' << std::any_cast < bool > ( elementas ) << std::endl;
} Kitas {
std::cout << 'Nežinomas tipas' << std::endl;
}
}
grąžinti 0 ;
}
Šioje iliustracijoje demonstruojame mišraus tipo konteinerio koncepciją naudojant C++ ir funkciją „std::any“. Sukuriame „std::vector
Kai kartojame „mixedContainer“ naudodami „for“ kilpą, naudojame funkciją type(), kad dinamiškai identifikuotume kiekvieno elemento duomenų tipą. Naudodami „std::any_cast“, išgauname ir spausdiname atitinkamas reikšmes pagal jų tipus. Pavyzdžiui, jei elemento tipas yra „int“, spausdiname jį kaip sveikąjį skaičių. Jei jis yra „dvigubas“, spausdiname kaip dvigubą ir pan.
Štai sugeneruota išvestis:
4 pavyzdys: klaidų tvarkymas naudojant Std::Any
Klaidų tvarkymas naudojant „std::any“ apima patikrinimą, ar tipas palaikomas, ar išsaugota reikšmė. Šiame pavyzdyje parodome, kaip elgtis su nepalaikomais tipais:
#include#include
tarp pagrindinis ( ) {
std::any myAny = 42 ;
bandyti {
dviguba reikšmė = std::any_cast < dvigubai > ( mano Bet koks ) ;
std::cout << 'Vertė:' << vertė << std::endl;
} sugauti ( const std::bad_any_cast & tai yra ) {
std::cerr << 'Klaida:' << e.kas ( ) << std::endl;
}
grąžinti 0 ;
}
Pradedame inicijuodami „std::any“ kintamąjį „myAny“, kurio vertė yra 42 sveikojo skaičiaus tipo. Tolesniame bloke „try“ mes aiškiai bandome perkelti šią sveikojo skaičiaus reikšmę į „double“, naudodami operaciją „std::any_cast
Siekdami dailiai valdyti šią galimą klaidą, išimčių tvarkymą įgyvendiname naudodami bloką „sugauti“, kuris skirtas konkrečiam išimties tipui „std::bad_any_cast“. Nesėkmingo perdavimo atveju suaktyvinamas blokas „pagauti“ ir mes sugeneruojame klaidos pranešimą naudodami „std::cerr“, kad praneštume apie klaidos pobūdį. Ši klaidų valdymo strategija užtikrina, kad mūsų programa gali grakščiai valdyti situacijas, kai bandomasis tipas kertasi su tikruoju tipu, saugomu kintamajame „std::any“.
Išvada
Šiame straipsnyje mes ištyrėme „std::any“ taikymą C++, dinaminio tipo konteinerį, kuris C++ įvedamas įvairių tipų reikšmėms. Mes pademonstravome jo universalumą įvairiais pavyzdžiais, demonstruodami scenarijus, kurie svyruoja nuo paprasto naudojimo iki vartotojo nustatytų tipų ir nevienalyčių kolekcijų tvarkymo. Mes parodėme jo praktinį pritaikymą scenarijuose, kai duomenų tipas nėra žinomas kompiliavimo metu. Be to, mes ištyrėme klaidų apdorojimo būdus, pabrėždami, kaip svarbu grakščiai valdyti nepalaikomus tipus taikant išimtis.