U C++ programiranju, 'std::any' iz standardne biblioteke predložaka (STL) uvodi dinamičko tipkanje za rukovanje heterogenim podacima. Za razliku od tradicionalnih spremnika, 'std::any' omogućuje pohranjivanje vrijednosti bilo koje vrste unutar jednog spremnika, povećavajući fleksibilnost u scenarijima u kojima su tipovi podataka nepoznati ili variraju tijekom izvođenja. Ovaj tipski agnostički pristup promiče generičko programiranje koje razvojnim programerima omogućuje stvaranje prilagodljivijeg i izražajnijeg koda uz održavanje sigurnosti tipa. U ovom istraživanju proučit ćemo značajke 'std::any', njegove obrasce upotrebe i praktične primjere koji ilustriraju njegovu ulogu u pisanju robusnog i fleksibilnog C++ koda.
Primjer 1: Osnovna upotreba Std::Any
Prvo, istražimo jednostavan primjer da pokažemo temeljnu upotrebu 'std::any'. Razmotrite scenarij u kojem vam je potrebna funkcija za prihvaćanje različitih vrsta parametara:
Evo isječka koda:
#include
#uključi
void proces Bilo koji ( const std::any i vrijednost ) {
ako ( vrijednost.ima_vrijednost ( ) ) {
std::cout << 'Vrsta pohranjene vrijednosti: ' << vrijednost.vrsta ( ) .Ime ( ) << std::endl;
ako ( vrijednost.vrsta ( ) == typeid ( int ) ) {
std::cout << 'Vrijednost: ' << std::bilo koji_cast < int > ( vrijednost ) << std::endl;
} drugo ako ( vrijednost.vrsta ( ) == typeid ( dvostruko ) ) {
std::cout << 'Vrijednost: ' << std::bilo koji_cast < dvostruko > ( vrijednost ) << std::endl;
} drugo ako ( vrijednost.vrsta ( ) == typeid ( std::string ) ) {
std::cout << 'Vrijednost: ' << std::bilo koji_cast < std::string > ( vrijednost ) << std::endl;
} drugo {
std::cout << 'Nepodržana vrsta!' << std::endl;
}
} drugo {
std::cout << 'Nema vrijednosti pohranjene u std::any.' << std::endl;
}
}
int glavni ( ) {
proces Bilo koji ( 42 ) ;
proces Bilo koji ( 3.14 ) ;
proces Bilo koji ( std::string ( 'Zdravo, std::any!' ) ) ;
proces Bilo koji ( 4.5f ) ; // Nepodržano tip
povratak 0 ;
}
U ovom primjeru definiramo funkciju “processAny” koja uzima referencu “std::any” kao parametar i ispituje njezin sadržaj. Unutar funkcije prvo provjeravamo ima li varijabla “std::any” pohranjenu vrijednost koristeći has_value(). Ako je vrijednost prisutna, određujemo tip pohranjene vrijednosti pomoću type().name() i nastavljamo s ispisom odgovarajuće vrijednosti na temelju njezinog tipa. Glavna funkcija zatim demonstrira korisnost 'processAny' pozivajući ga s različitim tipovima: cijeli broj (42), double (3.14) i niz ('Hello, std::any!'). Funkcija na odgovarajući način rukuje svakom vrstom i ispisuje odgovarajuće vrijednosti. Međutim, pri pokušaju obrade broja s pomičnim zarezom (4.5f), koji u ovom primjeru nije podržan, program elegantno rješava situaciju pokazujući da tip nije podržan.
Generirani izlaz je:
Ovo prikazuje kako 'std::any' omogućuje dinamičko rukovanje različitim tipovima podataka, što ga čini svestranim alatom za generičko programiranje u C++.
Primjer 2: Pohranjivanje korisnički definiranih tipova
Drugi primjer istražuje kako ovaj dinamički tip unutar biblioteke standardnih predložaka (STL) neprimjetno prilagođava prilagođene strukture podataka. Fokusirajući se na korisnički definirani tip, strukturu točke, prikazujemo kako 'std::any' rukuje instancama takvih struktura.
Evo koda:
#include#uključi
klasa MyClass {
javnost:
Moj razred ( int vrijednost ) : podaci ( vrijednost ) { }
void printData ( ) konst {
std::cout << 'Podaci u MyClass: ' << podaci << std::endl;
}
privatna:
int podataka;
} ;
int glavni ( ) {
std::any anyObject = MyClass ( 42 ) ;
ako ( anyObject.has_value ( ) ) {
auto i myClassInstance = std::any_cast < Moj razred &> ( bilo koji Objekt ) ;
myClassInstance.printData ( ) ;
} drugo {
std::cout << 'Nema vrijednosti pohranjene u std::any.' << std::endl;
}
povratak 0 ;
}
U ovom C++ isječku koda stvaramo jednostavan primjer za ilustraciju korištenja tipa 'std::any' s korisnički definiranom klasom pod nazivom 'MyClass'. Unutar klase postoji privatna varijabla članica koja se zove 'data' i javna metoda koja se zove printData() za prikaz vrijednosti ovih podataka. Cjelobrojna vrijednost se prosljeđuje i dodjeljuje članu 'data' u konstruktoru.
U funkciji “main” instanciramo objekt “MyClass” s početnom vrijednošću 42 i zatim ga pohranjujemo u varijablu “std::any” pod nazivom “anyObject”. Ovo pokazuje sposobnost 'std::any' da drži instance korisnički definiranih klasa.
Nakon toga koristimo naredbu “if” da provjerimo ima li “anyObject” vrijednost koristeći metodu has_value(). Ako postoji vrijednost, dohvaćamo pohranjeni objekt koristeći “std::any_cast”. “std::any_cast” koristi se s argumentom predloška “MyClass&” za pretvaranje pohranjenog objekta u referencu “MyClass”. Ova referenca, 'myClassInstance', zatim se koristi za pozivanje metode printData(), prikazujući mogućnost pristupa i rada s pohranjenim korisnički definiranim tipom unutar 'std::any'.
Ako nijedna vrijednost nije pohranjena u “std::any”, ispisujemo poruku koja to označava. Ova uvjetna provjera osigurava da rješavamo scenarije u kojima bi varijabla 'std::any' mogla biti prazna.
Evo rezultata:
Primjer 3: Spremnik mješovitih vrsta
U programiranju, 'spremnik mješovitog tipa' odnosi se na podatkovnu strukturu koja može držati elemente različitih, potencijalno nepovezanih tipova podataka. Ova fleksibilnost je vrijedna kada se radi o scenarijima u kojima su tipovi podataka nepoznati u vrijeme kompajliranja ili se dinamički mijenjaju tijekom izvođenja programa. U C++, 'std::any' predstavlja primjer ovog koncepta, dopuštajući stvaranje jednog spremnika za pohranjivanje vrijednosti različitih tipova.
Istražimo scenarij u kojem stvaramo spremnik koji sadrži različite vrste:
#include#uključi
#uključi
int glavni ( ) {
std::vektor < std::bilo koji > mixedContainer;
mixedContainer.push_back ( 42 ) ;
mixedContainer.push_back ( 3.14 ) ;
mixedContainer.push_back ( std::string ( 'Zdravo' ) ) ;
mixedContainer.push_back ( pravi ) ;
za ( const auto i element : mixedContainer ) {
ako ( element.vrsta ( ) == typeid ( int ) ) {
std::cout << 'Cijeli broj: ' << std::bilo koji_cast < int > ( element ) << std::endl;
} drugo ako ( element.vrsta ( ) == typeid ( dvostruko ) ) {
std::cout << 'Dvostruko: ' << std::bilo koji_cast < dvostruko > ( element ) << std::endl;
} drugo ako ( element.vrsta ( ) == typeid ( std::string ) ) {
std::cout << 'Niz: ' << std::bilo koji_cast < std::string > ( element ) << std::endl;
} drugo ako ( element.vrsta ( ) == typeid ( bool ) ) {
std::cout << 'Booleov:' << std::bilo koji_cast < bool > ( element ) << std::endl;
} drugo {
std::cout << 'Nepoznata vrsta' << std::endl;
}
}
povratak 0 ;
}
Na ovoj ilustraciji demonstriramo koncept spremnika mješovitog tipa koristeći C++ i značajku 'std::any'. Stvaramo “std::vector
Dok ponavljamo kroz 'mixedContainer' koristeći petlju 'for', koristimo funkciju type() da dinamički identificiramo tip podataka svakog elementa. Koristeći 'std::any_cast', izdvajamo i ispisujemo odgovarajuće vrijednosti na temelju njihovih tipova. Na primjer, ako je element tipa 'int', ispisujemo ga kao cijeli broj. Ako je tipa 'double', ispisujemo ga kao double, i tako dalje.
Evo generiranog izlaza:
Primjer 4: Rješavanje grešaka sa Std::Any
Rukovanje pogreškama pri korištenju “std::any” uključuje provjeru je li tip podržan ili je li vrijednost pohranjena. U ovom primjeru pokazujemo kako postupati s nepodržanim vrstama:
#include#uključi
int glavni ( ) {
std::any myAny = 42 ;
probati {
dvostruka vrijednost = std::any_cast < dvostruko > ( mojBilo koji ) ;
std::cout << 'Vrijednost: ' << vrijednost << std::endl;
} ulov ( const std::bad_any_cast i to je ) {
std::cerr << 'Pogreška: ' << e.što ( ) << std::endl;
}
povratak 0 ;
}
Počinjemo inicijaliziranjem varijable “std::any”, “myAny”, s vrijednošću 42 integer tipa. Unutar sljedećeg bloka “try” izričito pokušavamo pretvoriti ovu vrijednost cijelog broja u “double” pomoću operacije “std::any_cast
Kako bismo elegantno upravljali ovom potencijalnom pogreškom, implementiramo rukovanje iznimkama s blokom 'catch' koji je dizajniran za hvatanje specifične vrste iznimke 'std::bad_any_cast'. U slučaju neuspješnog bacanja, aktivira se blok 'catch' i mi generiramo poruku o pogrešci pomoću 'std::cerr' za priopćavanje prirode pogreške. Ova strategija rukovanja pogreškama osigurava da se naš program može elegantno nositi sa situacijama u kojima se pokušano pretvaranje tipa sukobljava sa stvarnim tipom koji je pohranjen u varijabli 'std::any'.
Zaključak
U ovom smo članku istražili primjene 'std::any' u C++, spremniku dinamičkog tipa koji je uveden u C++ za vrijednosti različitih tipova. Pokazali smo njegovu svestranost kroz različite primjere, prikazujući scenarije koji se kreću od osnovne upotrebe do rukovanja korisnički definiranim tipovima i heterogenim zbirkama. Demonstrirali smo njegovu praktičnu primjenu u scenarijima u kojima vrsta podataka nije poznata u vrijeme kompajliranja. Osim toga, istražili smo tehnike rukovanja pogreškama, naglašavajući važnost elegantnog upravljanja nepodržanim tipovima kroz rukovanje iznimkama.