Tietotyyppien muuntaminen C++:ssa
C++:ssa on kaksi tapaa muuttaa tietotyyppejä:
Implisiittisen tyypin muunnos
C++-koodikääntäjän ennalta määrittämien sääntöjen mukaan implisiittinen tyyppimuunnos on kääntäjän automaattisesti suorittama tyyppimuunnos ilman, että käyttäjä tarvitsee ulkoista laukaisua. Tämän tyyppinen muunnos tapahtuu yleensä ohjelmassa, kun tietotyyppejä on useampia ja lausekkeen tietotyyppi ei vastaa tähän lausekkeeseen liittyvän muuttujan tietotyyppiä.
Tietojen häviämisen välttämiseksi muunnoksen aikana kääntäjä muuttaa oletusarvoisesti matalan tarkkuuden tietotyypiksi tarkemman tietotyypin. Se esimerkiksi muuntaa kokonaisluvun floatiksi sen sijaan, että muuttaisi floatin kokonaisluvuksi tietojen häviämisen estämiseksi. Tätä kutsutaan promootioksi. Seuraavassa on ensisijaisuuskaavio eri tietotyypeille.
Tilaus tyyppimuunnokselle
Oikea järjestys tyyppimuunnokselle annetaan seuraavasti:
bool -- > char -- > lyhyt int -- > int -- > allekirjoittamaton int -- > pitkä -- > allekirjoittamaton pitkä -- > pitkä pitkä -- > kellua -- > kaksinkertainen -- > pitkä tupla
Pienen tarkkuuden tyyppimuuttuja muunnetaan suuren tarkkuuden tietotyypiksi tietojen häviämisen estämiseksi.
Esimerkki 1
Tässä esimerkissä summaus suoritetaan eri tietotyyppien muuttujille käyttämällä implisiittistä tyyppimuunnosa.
#include
käyttämällä nimiavaruus std ;
int pää ( ) {
int määrä = 100 ;
hiiltyä merkki = 'C' ;
cout << '100 + 'C' =' << määrä + merkki << endl ;
kellua val = määrä + 'c' ;
cout << 'float val(100 + 'c') = ' << val << endl ;
int oli = 7890 ;
pitkä ei ollut = oli ;
cout << 'var_int = ' << ei ollut ;
palata 0 ;
}
Tähän lisätään kokonaisluku ja merkki ASCII-taulukosta sekä liukuluku ja merkki 'c'. Kokonaisluku säilytetään kolmannessa segmentissä pitkänä tietotyyppinä ja kääntäjä itse muuttaa tietotyyppejä ennalta määritettyjen sääntöjensä perusteella.
Summa 100 ja 'C' palauttaa 167, koska 'C' vastaa 67:ää numeroina ja 100+'c' palauttaa 199 pienellä c on 99. Int-muuttuja on tallennettu pitkälle tietotyypille.
Esimerkki 2
Tässä esimerkissä merkki D muunnetaan floatiksi jakotoiminnon suorittamiseksi.
#includekäyttämällä nimiavaruus std ;
int pää ( ) {
hiiltyä x = 'D' ;
kellua float_var ;
float_var = kellua ( x ) / 'c' ;
// Int:n muuntaminen kelluviksi.
cout << 'Paran float_var arvo on: ' << float_var << endl ;
palata 0 ;
}
Syöttöarvo on merkin D muodossa, joka tallennetaan float-tietotyyppiin ja jaetaan edelleen merkillä C. Nämä merkit muutetaan numeerisiksi arvoiksi ja niille suoritetaan jakotoiminto, joka palauttaa arvon float-muodossa.
Eksplisiittisen tyypin muunnos
Käyttäjän on muutettava tietotyyppi manuaalisesti C++:n eksplisiittisellä tyyppimuunnolla, joka tunnetaan usein nimellä tyyppivalu. Tämän tyyppinen valu tehdään implisiittisen tyypin muuntamisen välttämiseksi. Explicit Type Casting -suoraan C++:ssa on kaksi tapaa:
- Muunnos tehtäväoperaattorilla
- Muuntaminen Cast-operaattorilla
Kirjoita Conversion C++:n Assignment Operatorilla
Tyyppimuunnos Assignment Operator -toiminnolla tehdään väkisin, eli yksi tietotyyppi muunnetaan toiseksi manuaalisesti. Tämä saadaan aikaan käyttämällä määritysoperaattoria '=', joka määrittää oikeanpuoleisen operandin arvon sen vasemmalla puolella olevalle muuttujalle.
Esimerkki
Tämä ohjelma laskee ympyrän alueen tyyppivalulla.
#include
käyttämällä nimiavaruus std ;
int pää ( )
{
int säde ;
cout <> säde ;
kellua alueella = M_PI * säde * säde ;
cout << 'Ympyrän alue säteellä' << säde << '=' << alueella ;
}
Kohdistusoperaattorilla asetetaan alueelle float-arvo, joka koostuu säteen arvosta kokonaislukutietotyypissä.
Ympyrän pinta-ala palautetaan float-tietotyypillä, kun taas säde syötetään kokonaislukutietotyypissä. Siten muuttujan tietotyyppiä muutetaan tyyppivalulla määritysoperaattorilla.
Kirjoita muunnos Cast-operaattorilla C++:ssa
Tyyppimuunnos tehdään cast-operaattorilla, joka pakottaa yhden tietotyypin vaihtamaan toisen tyypin ohjelman tarpeiden mukaan.
Cast-operaattoreita on neljä:
- static_cast
- const_cast
- dynaaminen_cast
- tulkita uudelleen
1: static_cast
Static_cast on casting-operaattori, jota käytetään eksplisiittisesti muuttamaan kellukkeet ja merkit kokonaisluvuiksi ja niin edelleen. Tämä on yksinkertaisin cast-operaattori. Se voi lähettää tietotyyppejä, jotka ovat luonteeltaan samanlaisia. Se voi muuntaa osoittimia lomakkeesta toiseen, joten sitä voidaan käyttää myös muistin hallintaan.
Syntaksi
static_cast ( ilmaisu ) Esimerkki
Tämä ohjelma on rakennettu muuntamaan kaksoismuuttuja int-tietotyypiksi käyttämällä static_cast-toimintoa. Se katkaisee tulosteen minkä tahansa desimaaliosan.
käyttämällä nimiavaruus std ;
int pää ( )
{
// ilmoittaa muuttuja
kaksinkertainen s ;
s = 2,905 * 1,235 * 24,675 ;
kellua tulos ;
cout << ' Ennen staattisen heiton käyttöä:' << endl ;
cout << ' p = ' << s << endl ;
// käytä static_cast-funktiota datatyypin muuntamiseen
tulos = static_cast ( s ) ;
cout << ' Staattisen heiton käytön jälkeen: ' << endl ;
cout << ' Tuloksen arvo = ' << tulos << endl ;
palata 0 ;
}
Aluksi kaksoismuuttuja p ladataan arvoilla, jotka kerrotaan keskenään ja tallennetaan tulokseen. Tulos sisältää tuloksen ennen static_cast-operaattoria ja sen jälkeen:
Ennen static_cast-operaattorin käyttöä tulos näytetään desimaalipisteinä, kun taas tämän operaattorin käytön jälkeen se näytetään kokonaislukutietotyypeissä.
2: const_cast
Const_cast-operaattoria käytetään muuntamaan objektin vakioarvo ei-vakiotyypiksi. Sitä käytetään, kun vakioobjekti on ilmoitettu, ja meidän on muutettava sen arvoa ajoittain.
Syntaksi
const_cast ( ilmaisu ) Esimerkki
Tässä esimerkissä const_cast-operaattoria käytetään vakiotunnisteen poistamiseen väliaikaisesti ja se sallii muuttujan muuttamisen tarpeen mukaan:
käyttämällä nimiavaruus std ;
int pää ( ) {
konst int x = 70 ;
konst int * ja = & x ;
cout << 'Vanha arvo on' << * ja << ' \n ' ;
int * Kanssa = const_cast ( ja ) ;
* Kanssa = 90 ;
cout << 'Uusi arvo on' << * ja ;
palata 0 ;
}
Vakiotunniste on liitetty int-muuttujaan x, mikä tarkoittaa, että tätä muuttujaa ei voi muokata suoraan. Tämän jälkeen int *y, joka on osoitin, käytetään x:n käyttämiseen, mutta silti sitä ei voi muuttaa, ja sen alkuperäinen arvo näytetään komennolla cout. Const_cast-operaattorilla luodaan osoitin z, joka ei ole vakio. Sitä käytetään x:n arvon saamiseen, jolloin se on muokattavissa. Se muuttaa z:lle määritettyä arvoa 90:llä, mikä muuttaa epäsuorasti x:n arvoa.
Aluksi vakiomuuttujan x arvo on 70, jota muutetaan käyttämällä const_cast-operaattoria, jolloin se on 90.
3: dynaaminen_cast
periytymishierarkialla, jota kutsutaan myös tyyppiturvalliseksi alaslaskuksi. Alaslasku on prosessi, jossa viite tai osoitin muunnetaan johdetuksi luokaksi perusluokan viittauksesta tai osoittimesta.
Syntaksi
dynaaminen_cast ( ilmaisu ) Esimerkki
Tässä esimerkissä dynamic_cast-operaattoria käytetään polymorfisen luokan tyypin tarkistamiseen, ja se mahdollistaa pääsyn sekä perus- että johdettuihin luokan jäseniin.
#sisällytä
käyttämällä nimiavaruus std ;
luokkaa TBase
{
julkinen :
kellua base_g = 9.81 ;
virtuaalinen mitätön nukke ( )
{
} ;
} ;
luokkaa TDived : julkinen TBase
{
julkinen :
int paikallinen_g = 9.78 ;
} ;
int pää ( )
{
TBase * pohja = Uusi TDived ;
TDived * johdettu ;
johdettu = dynaaminen_cast ( pohja ) ;
cout < base_g << endl ;
cout < paikallinen_g << endl ;
getchar ( ) ;
palata 0 ;
}
Kaksi luokkaa määritellään perusluokiksi ja johdetuiksi luokiksi. TBase*-tyyppinen osoitinkanta luodaan ja määritetään dynaamisesti allokoidulle TDerived-tyyppiselle objektille. Johdettu luokkaobjekti voidaan määrittää perusluokan osoittimelle tässä polymorfismin tapauksessa. Dynaaminen_cast tarkistaa, pääseekö osoitin TDerivedin kelvolliseen objektiin, jos cast saa onnistuneen tuloksen, johdettu luokka saa kelvollisen tuloksen, muuten se palauttaa nolla-arvon.
4: reinterpret_cast
Reinterpret_cast muuttaa yhden tietotyypin osoittimen eri tietotyypin osoittimeksi. Se ei tarkista, ovatko osoittimien tietotyypit samat vai eivät. Tätä valukoneistoa on käytettävä ja käsiteltävä huolellisesti.
Esimerkki
Tässä kuvassa yhden tietotyypin osoitin tulkitaan uudelleen toisen tietotyypin osoittimeksi käyttämällä reinterpret_cast-komentoa:
käyttämällä nimiavaruus std ;
int pää ( )
{
int * q = Uusi int ( 70 ) ;
hiiltyä * ch = tulkita uudelleen ( q ) ;
cout << * q << endl ;
cout << * ch << endl ;
cout << q << endl ;
cout << ch << endl ;
palata 0 ;
}
Aluksi annetaan kokonaisluku, jonka arvo on 70. Osoitin q osoittaa tähän dynaamisesti allokoituun kokonaislukuun. Reinterpret_cast-komentoa käytetään osoittimen q tulkitsemiseen uudelleen merkkiosoittimeksi ch, mikä tarkoittaa, että q:lle alun perin määritettyä muistia käsitellään nyt ikään kuin se olisi merkki. Cout-komennolla se tulostaa q:lle ja ch:lle määritetyn arvon. Koska ch:tä käsitellään merkkiosoittimena, se palauttaa merkin arvon.
Se tulostaa arvon, joka osoittaa ch:lle käyttämällä *ch:tä. Koska ch:tä käsitellään kuitenkin merkkiosoittimena, tämä rivi tulkitsee muistin merkiksi. Se tulostaa osoittimeen ch tallennetun muistiosoitteen ch:n avulla. Tämä on sama muistiosoite kuin q, koska se on vain uudelleentulkinta samasta muistista.
Aluksi kokonaisluku tallentaa 70. Myöhemmin tätä käsitellään osoittimen q ja osoittimen ch välillä. Lähdöt 2 ja 4 ovat samat, koska toinen arvo tulkitaan uudelleen käyttämällä reinterpret_cast.
Huomautus : On suositeltavaa, että tätä cast-operaattoria ei käytetä ennen kuin ja ellei sitä ole paljon tarpeen, koska se tekee esineestä ei-kannettavan tuotteen
Johtopäätös
Prosessi, jossa muuttujan tietotyyppi muutetaan toiseksi, tunnetaan C++:ssa tyyppimuunnoksena tai tyypin valuna. Tämä tehdään matemaattisten operaatioiden suorittamiseksi eri tietotyyppien muuttujille tekemällä niiden tietotyypit yhteensopiviksi keskenään. Tyyppimuunnos optimoi koodin. C++:ssa on implisiittisiä ja eksplisiittisiä tyyppimuunnoksia. Kääntäjä itse suorittaa implisiittisen tyyppimuunnoksen käyttämällä ennalta määritettyä sääntöjoukkoa, kun taas eksplisiittisen tyyppimuunnoksen suorittaa ohjelmoija käyttämällä osoitusoperaattoreita ja cast-operaattoreita.