C++-ohjelmoinnissa Standard Template Libraryn (STL) 'std::any' ottaa käyttöön dynaamisen kirjoituksen heterogeenisten tietojen käsittelemiseksi. Toisin kuin perinteiset säilöt, 'std::any' mahdollistaa minkä tahansa tyyppisten arvojen tallentamisen yhteen säilöön, mikä lisää joustavuutta skenaarioissa, joissa tietotyypit ovat tuntemattomia tai vaihtelevat ajon aikana. Tämä tyyppiagnostinen lähestymistapa edistää yleistä ohjelmointia, joka antaa kehittäjille mahdollisuuden luoda mukautuvampaa ja ilmeikkäämpää koodia säilyttäen samalla tyypin turvallisuuden. Tässä tutkimuksessa perehdymme 'std::any' -koodin ominaisuuksiin, sen käyttötapoihin ja käytännön esimerkkeihin, jotka havainnollistavat sen roolia vankan ja joustavan C++-koodin kirjoittamisessa.
Esimerkki 1: Std::Anyn peruskäyttö
Tarkastellaan ensin suoraviivaista esimerkkiä, joka osoittaa 'std::any' -sanan peruskäytön. Harkitse tilannetta, jossa tarvitset funktion erityyppisten parametrien hyväksymiseen:
Tässä koodinpätkä:
#include
#sisällytä
mitätön prosessi Mikä tahansa ( const std::any & arvo ) {
jos ( arvo.on_arvo ( ) ) {
std::cout << 'Tallennetun arvon tyyppi:' << arvon tyyppi ( ) .nimi ( ) << std::endl;
jos ( arvon tyyppi ( ) == kirjoitettu ( int ) ) {
std::cout << 'Arvo:' << std::any_cast < int > ( arvo ) << std::endl;
} muu jos ( arvon tyyppi ( ) == kirjoitettu ( kaksinkertainen ) ) {
std::cout << 'Arvo:' << std::any_cast < kaksinkertainen > ( arvo ) << std::endl;
} muu jos ( arvon tyyppi ( ) == kirjoitettu ( std::string ) ) {
std::cout << 'Arvo:' << std::any_cast < std::string > ( arvo ) << std::endl;
} muu {
std::cout << 'Tyyppiä ei tueta!' << std::endl;
}
} muu {
std::cout << 'Std::any-tiedostoon ei ole tallennettu arvoa.' << std::endl;
}
}
int main ( ) {
käsitellä mitä tahansa ( 42 ) ;
käsitellä mitä tahansa ( 3.14 ) ;
käsitellä mitä tahansa ( std::string ( 'Hei, std::any!' ) ) ;
käsitellä mitä tahansa ( 4.5f ) ; // Ei tuettu tyyppi
palata 0 ;
}
Tässä esimerkissä määrittelemme 'processAny'-funktion, joka ottaa 'std::any'-viittauksen parametriksi ja tutkii sen sisältöä. Toiminnon sisällä tarkistamme ensin, onko 'std::any'-muuttujalla tallennettu arvo käyttämällä has_value(). Jos arvo on olemassa, määritämme tallennetun arvon tyypin käyttämällä type().name()-komentoa ja jatkamme vastaavan arvon tulostamista sen tyypin perusteella. Pääfunktio osoittaa sitten 'processAny':n hyödyllisyyden kutsumalla sitä eri tyypeillä: kokonaisluku (42), kaksoisluku (3.14) ja merkkijono ('Hei, std::any!'). Funktio käsittelee kunkin tyypin asianmukaisesti ja tulostaa vastaavat arvot. Kun kuitenkin yritetään käsitellä liukulukua (4.5f), jota ei tueta tässä esimerkissä, ohjelma käsittelee tilanteen sulavasti ilmoittamalla, että tyyppiä ei tueta.
Luotu tulos on:
Tämä osoittaa, kuinka 'std::any' mahdollistaa eri tietotyyppien dynaamisen käsittelyn, mikä tekee siitä monipuolisen työkalun yleiseen ohjelmointiin C++:ssa.
Esimerkki 2: Käyttäjän määrittämien tyyppien tallentaminen
Toisessa esimerkissä tutkitaan, kuinka tämä dynaaminen tyyppi Standard Template Libraryssa (STL) mukautuu saumattomasti mukautettuihin tietorakenteisiin. Keskitymällä käyttäjän määrittelemään tyyppiin, pisterakenteeseen, esittelemme, kuinka 'std::any' käsittelee tällaisten rakenteiden esiintymiä.
Tässä on koodi:
#include#sisällytä
luokka MyClass {
julkinen:
Luokkani ( int arvo ) : data ( arvo ) { }
mitätön printData ( ) konst {
std::cout << 'Data in MyClass:' << tiedot << std::endl;
}
yksityinen:
int tiedot;
} ;
int main ( ) {
std::any anyObject = MyClass ( 42 ) ;
jos ( anyObject.has_value ( ) ) {
auto & myClassInstance = std::any_cast < Luokkani &> ( mikä tahansa esine ) ;
myClassInstance.printData ( ) ;
} muu {
std::cout << 'Std::any-tiedostoon ei ole tallennettu arvoa.' << std::endl;
}
palata 0 ;
}
Tässä C++-koodinpätkässä luomme yksinkertaisen esimerkin havainnollistamaan 'std::any'-tyyppiä käyttäjän määrittämän luokan 'MyClass' kanssa. Luokassa on yksityinen jäsenmuuttuja nimeltä 'data' ja julkinen menetelmä nimeltä printData() näiden tietojen arvon näyttämiseksi. Kokonaislukuarvo välitetään ja määritetään rakentajan 'data'-jäsenelle.
'Main'-funktiossa instantoimme 'MyClass'-objektin, jonka alkuarvo on 42, ja tallennamme sen sitten 'std::any'-muuttujaan nimeltä 'anyObject'. Tämä osoittaa 'std::any':n kyvyn pitää sisällään käyttäjän määrittämien luokkien esiintymät.
Tämän jälkeen käytämme 'if'-lausetta tarkistaaksemme, onko 'anyObject'-arvolla has_value()-metodin avulla. Jos arvo on olemassa, haemme tallennetun objektin käyttämällä 'std::any_cast'. 'std::any_cast' käytetään 'MyClass&'-mallipohjan argumentin kanssa tallennetun objektin lähettämiseksi 'MyClass'-viitteeseen. Tätä viittausta, 'myClassInstance', käytetään sitten kutsumaan printData()-menetelmää, mikä osoittaa kyvyn käyttää tallennettua käyttäjän määrittämää tyyppiä ja käyttää sitä 'std::any' -kentässä.
Jos arvoa ei ole tallennettu kohtaan 'std::any', tulostamme tämän ilmaisevan viestin. Tämä ehdollinen tarkistus varmistaa, että käsittelemme skenaarioita, joissa 'std::any'-muuttuja saattaa olla tyhjä.
Tässä on tulos:
Esimerkki 3: Sekatyyppiset säiliöt
Ohjelmoinnissa 'sekatyyppisellä säiliöllä' tarkoitetaan tietorakennetta, joka pystyy säilyttämään erilaisten, mahdollisesti toisiinsa liittymättömien tietotyyppien elementit. Tämä joustavuus on arvokasta käsiteltäessä skenaarioita, joissa tietotyypit ovat tuntemattomia käännöshetkellä tai muuttuvat dynaamisesti ohjelman suorittamisen aikana. C++:ssa 'std::any' on esimerkki tästä käsitteestä, mikä mahdollistaa yhden säilön luomisen eri tyyppisten arvojen tallentamiseen.
Tutkitaan skenaariota, jossa luomme säilön, joka sisältää eri tyyppejä:
#include#sisällytä
#sisällytä
int main ( ) {
std::vektori < std::mikä tahansa > sekoitettu Container;
mixContainer.push_back ( 42 ) ;
mixContainer.push_back ( 3.14 ) ;
mixContainer.push_back ( std::string ( 'Hei' ) ) ;
mixContainer.push_back ( totta ) ;
varten ( const auto & elementti: mixContainer ) {
jos ( element.type ( ) == kirjoitettu ( int ) ) {
std::cout << 'Kokonaisluku:' << std::any_cast < int > ( elementti ) << std::endl;
} muu jos ( element.type ( ) == kirjoitettu ( kaksinkertainen ) ) {
std::cout << 'Kaksinkertainen: ' << std::any_cast < kaksinkertainen > ( elementti ) << std::endl;
} muu jos ( element.type ( ) == kirjoitettu ( std::string ) ) {
std::cout << 'String:' << std::any_cast < std::string > ( elementti ) << std::endl;
} muu jos ( element.type ( ) == kirjoitettu ( bool ) ) {
std::cout << 'Boolean:' << std::any_cast < bool > ( elementti ) << std::endl;
} muu {
std::cout << 'Tuntematon tyyppi' << std::endl;
}
}
palata 0 ;
}
Tässä kuvassa esittelemme sekatyyppisen säiliön konseptia käyttämällä C++:aa ja 'std::any'-ominaisuutta. Luomme 'std::vector
Kun iteroimme 'mixedContainer':n läpi käyttämällä 'for'-silmukkaa, käytämme type()-funktiota tunnistamaan kunkin elementin tietotyyppi dynaamisesti. Hyödyntämällä 'std::any_cast' poimimme ja tulostamme vastaavat arvot niiden tyyppien perusteella. Jos elementti on esimerkiksi tyyppiä 'int', tulostamme sen kokonaislukuna. Jos se on tyyppiä 'double', tulostamme sen kaksoiskappaleena ja niin edelleen.
Tässä on tuotettu tulos:
Esimerkki 4: Virheiden käsittely Std::Any:lla
Virheiden käsittely käytettäessä 'std::any' sisältää sen tarkistamisen, onko tyyppiä tuettu tai onko arvo tallennettu. Tässä esimerkissä näytämme, kuinka käsitellä ei-tuettuja tyyppejä:
#include#sisällytä
int main ( ) {
std::any myAny = 42 ;
yrittää {
kaksinkertainen arvo = std::any_cast < kaksinkertainen > ( minun Mikä tahansa ) ;
std::cout << 'Arvo:' << arvo << std::endl;
} ottaa kiinni ( const std::bad_any_cast & se on ) {
std::cerr << 'Virhe:' << e.mitä ( ) << std::endl;
}
palata 0 ;
}
Aloitamme alustamalla 'std::any'-muuttujan 'myAny' kokonaislukutyypin arvolla 42. Seuraavassa 'try'-lohkossa yritämme nimenomaisesti heittää tämän kokonaisluvun 'doubleksi' käyttämällä 'std::any_cast
Tämän mahdollisen virheen hallitsemiseksi sulavasti otamme käyttöön poikkeuskäsittelyn 'catch'-lohkolla, joka on suunniteltu saamaan kiinni tietyn poikkeustyypin 'std::bad_any_cast'. Jos heitto epäonnistuu, 'catch'-lohko aktivoituu ja luomme virheilmoituksen käyttämällä 'std::cerr' ilmoittamaan virheen luonteesta. Tämä virheenkäsittelystrategia varmistaa, että ohjelmamme pystyy käsittelemään sulavasti tilanteet, joissa yritetty tyyppilähetys on ristiriidassa 'std::any'-muuttujaan tallennetun todellisen tyypin kanssa.
Johtopäätös
Tässä artikkelissa tutkimme 'std::any':n sovelluksia C++:ssa, dynaamisessa tyyppisäilössä, joka on otettu käyttöön C++:ssa eri tyyppisten arvoille. Osoitimme sen monipuolisuuden useilla esimerkeillä ja esittelimme skenaarioita, jotka vaihtelevat peruskäytöstä käyttäjän määrittelemien tyyppien ja heterogeenisten kokoelmien käsittelyyn. Osoitimme sen käytännön sovelluksen skenaarioissa, joissa tiedon tyyppi ei ole tiedossa käännöshetkellä. Lisäksi tutkimme virheenkäsittelytekniikoita ja korostimme, että on tärkeää hallita ei-tuettuja tyyppejä sulavasti poikkeuskäsittelyn avulla.