Adattípusok konvertálása C++ nyelven
A C++ nyelven kétféleképpen lehet módosítani az adattípusokat:
Implicit típuskonverzió
A C++ kódfordító által előre meghatározott szabályok szerint az implicit típuskonverzió az a típuskonverzió, amelyet a fordító automatikusan végrehajt, anélkül, hogy a felhasználótól bármilyen külső triggerre lenne szükség. Ez a fajta átalakítás általában akkor megy végbe egy programban, ha egynél több adattípus létezik, és a kifejezés adattípusa nem egyezik a kifejezésben szereplő változó adattípusával.
Az átalakítás során az adatvesztés elkerülése érdekében a fordító alapértelmezés szerint az alacsony pontosságú adattípust a nagyobb pontosságú adattípusra változtatja. Például egy egész számot lebegőpontossá alakít, ahelyett, hogy a lebegőpontot egész számmá változtatná az adatvesztés elkerülése érdekében. Ezt promóciónak hívják. Az alábbiakban a különböző adattípusok elsőbbségi diagramja látható.
Rendelés típusátalakításhoz
A típusátalakítás helyes sorrendje a következő:
bool -- > char -- > rövid int -- > int -- > aláíratlan int -- > hosszú -- > aláíratlan hosszú -- > hosszú hosszú -- > úszó -- > dupla -- > hosszú dupla
Az alacsony pontosságú típusú változót nagy pontosságú adattípussá alakítja át az adatvesztés elkerülése érdekében.
1. példa
Ebben a példában az összeadás a különböző adattípusok változóin történik az implicit típuskonverzió segítségével.
#include
segítségével névtér std ;
int fő- ( ) {
int szám = 100 ;
char karakter = 'C' ;
cout << '100 + 'C' = ' << szám + karakter << endl ;
úszó val = szám + 'c' ;
cout << 'float val(100 + 'c') = ' << val << endl ;
int volt = 7890 ;
hosszú nem volt = volt ;
cout << 'var_int = ' << nem volt ;
Visszatérés 0 ;
}
Itt hozzáadódik egy egész szám és egy karakter az ASCII-táblából, valamint egy lebegő szám és egy „c” karakter. Az egész szám a harmadik szegmensben marad hosszú adattípusként, és az adattípusokat maga a fordító módosítja az előre meghatározott szabályok alapján.
A 100 és a 'C' összege 167-et ad vissza, mivel a 'C' számokban 67-nek felel meg, a 100+'c' pedig 199-et ad vissza, mivel a kisbetűs 'c' 99-nek felel meg. Az int változó hosszú adattípusban van tárolva.
2. példa
Ebben a példában a D karaktert lebegővé alakítjuk az osztási művelet végrehajtásához.
#includesegítségével névtér std ;
int fő- ( ) {
char x = 'D' ;
úszó float_var ;
float_var = úszó ( x ) / 'c' ;
// Egy int explicit átalakítása lebegőponttá.
cout << 'A float_var értéke: ' << float_var << endl ;
Visszatérés 0 ;
}
A bemeneti érték D karakter formájában van tárolva, amelyet lebegő adattípusban tárolunk, és C karakterrel tovább osztjuk. Ezeket a karaktereket számértékekké változtatjuk, és osztási műveletet hajtunk végre rajtuk, lebegve visszaadva az értéket.
Explicit típuskonverzió
A felhasználónak manuálisan kell módosítania az adattípust a C++ explicit típuskonverziójával, amelyet gyakran típusöntvénynek neveznek. Ezt a fajta öntést azért végezzük, hogy elkerüljük az implicit típuskonverziót. Két módszer létezik az explicit típusú öntvény végrehajtására C++ nyelven:
- Konverzió a hozzárendelési operátor segítségével
- Konvertálás a Cast Operator segítségével
Írja be a Conversion parancsot a hozzárendelési operátor segítségével C++ nyelven
A típuskonverzió a Hozzárendelés operátor használatával erõteljesen történik, vagyis az egyik adattípust manuálisan konvertálják a másikra. Ez a „=” hozzárendelési operátor használatával érhető el, amely a jobb oldali operandus értékét rendeli a bal oldalán lévő változóhoz.
Példa
Ez a program típusöntéssel számítja ki a kör területét.
#include
segítségével névtér std ;
int fő- ( )
{
int sugár ;
cout <> sugár ;
úszó terület = M_PI * sugár * sugár ;
cout << 'A kör sugarú területe' << sugár << ' = ' << terület ;
}
A hozzárendelési operátor a lebegőérték hozzárendelésére szolgál a területhez, amely az egész adattípusú sugár értékéből áll.
A kör területét float adattípusban, míg a sugarat egész adattípusban adjuk vissza. Így a változó adattípusa típusöntéssel módosul a hozzárendelési operátor használatával.
Írja be a Conversion parancsot a Cast operátor használatával C++ nyelven
A típuskonverzió egy cast operátor használatával történik, amely arra kényszeríti az egyik adattípust, hogy a program igényeinek megfelelően egy másik típusra váltson.
Négy különböző Cast operátor létezik:
- static_cast
- const_cast
- dynamic_cast
- reinterpret_cast
1: static_cast
A static_cast a casting operátor, amely a lebegőpontok és karakterek egész számokká és így tovább konvertálására szolgál. Ez a legalapvetőbb cast operátor. Olyan adattípusokat tud leadni, amelyek természetükben hasonlóak. A mutatókat egyik formáról a másikra tudja konvertálni, így memóriakezelésre is használható.
Szintaxis
static_cast ( kifejezés ) Példa
Ez a program úgy készült, hogy a static_cast használatával dupla változót int adattípussá alakítson. Levág minden tizedes részt a kimenetben.
segítségével névtér std ;
int fő- ( )
{
// deklarál egy változót
kettős p ;
p = 2,905 * 1,235 * 24 675 ;
úszó eredmény ;
cout << ' A statikus cast használata előtt:' << endl ;
cout << ' p = ' értéke << p << endl ;
// használja a static_castot az adattípus konvertálásához
eredmény = static_cast ( p ) ;
cout << ' A statikus cast használata után: ' << endl ;
cout << ' Az eredmény értéke = ' << eredmény << endl ;
Visszatérés 0 ;
}
Kezdetben egy dupla p változót töltünk be olyan értékekkel, amelyeket egymással megszorozunk és az eredményben tárolunk. Az eredmény a static_cast operátor előtti és utáni eredményt tartalmazza:
A static_cast operátor használata előtt az eredmény tizedespontokban, míg az operátor használata után egész adattípusban jelenik meg.
2: const_cast
A const_cast operátor egy objektum állandó értékét nem állandó típussá alakítja át. Ott használatos, ahol állandó objektum van deklarálva, és időnként módosítanunk kell az értékét.
Szintaxis
const_cast ( kifejezés ) Példa
Ebben a példában a const_cast operátor a konstans minősítő ideiglenes eltávolítására szolgál, és lehetővé teszi a változó igény szerinti módosítását:
segítségével névtér std ;
int fő- ( ) {
const int x = 70 ;
const int * és = & x ;
cout << 'Régi érték' << * és << ' \n ' ;
int * Val vel = const_cast ( és ) ;
* Val vel = 90 ;
cout << 'Az új érték' << * és ;
Visszatérés 0 ;
}
A konstans minősítő egy x int változóhoz van rendelve, ami azt jelenti, hogy ez a változó közvetlenül nem módosítható. Ezt követően az int *y, amely egy mutató, az x eléréséhez használható, de mégsem változtatható meg, és az eredeti értéke a cout segítségével jelenik meg. A const_cast operátor segítségével létrejön egy z mutató, amely nem állandó, az x érték elérésére szolgál, így szerkeszthetővé válik. Megváltoztatja a z-hez rendelt értéket 90-el, ami közvetve megváltoztatja az x-ben lévő értéket.
Kezdetben az x állandó változó értéke 70, amelyet a const_cast operátorral módosítunk, így 90 lesz.
3: dynamic_cast
az öröklődési hierarchiával, amelyet típusbiztos lecsúszásnak is neveznek. A lefelé leadás az a folyamat, amikor egy hivatkozást vagy mutatót egy alaposztályhivatkozásból vagy mutatóból származtatott osztályba konvertálunk.
Szintaxis
dynamic_cast ( kifejezés ) Példa
Ebben a példában a dynamic_cast operátort használjuk a polimorf osztály típusának ellenőrzésére, és lehetővé teszi az alap és a származtatott osztálytagok elérését.
#include
segítségével névtér std ;
osztály TBase
{
nyilvános :
úszó alap_g = 9.81 ;
virtuális üres színlelt ( )
{
} ;
} ;
osztály TSzármaztatott : nyilvános TBase
{
nyilvános :
int helyi_g = 9.78 ;
} ;
int fő- ( )
{
TBase * bázis = új TSzármaztatott ;
TSzármaztatott * származtatott ;
származtatott = dynamic_cast ( bázis ) ;
cout < alap_g << endl ;
cout < helyi_g << endl ;
getchar ( ) ;
Visszatérés 0 ;
}
Két osztály van definiálva alap- és származtatott osztályként. Létrejön egy TBase* típusú mutatóbázis, és hozzárendelődik egy dinamikusan lefoglalt TDerived típusú objektumhoz. Ebben a polimorfizmusban egy származtatott osztályobjektum hozzárendelhető egy alaposztály-mutatóhoz. A dynamic_cast ellenőrzi, hogy a mutató hozzáfér-e a TDerived érvényes objektumához, ha a cast sikeres eredményt kap, a származtatott osztály érvényes eredményt kap, ellenkező esetben null értéket ad vissza.
4: reinterpret_cast
A reinterpret_cast egy adattípus mutatóját egy másik adattípusú mutatóvá alakítja át. Nem ellenőrzi, hogy a mutatók adattípusai azonosak-e vagy sem. Ezt az öntvénykezelőt óvatosan kell használni és kezelni.
Példa
Ezen az ábrán az egyik adattípus mutatója újraértelmezésre kerül egy másik adattípus mutatójává a reinterpret_cast használatával:
segítségével névtér std ;
int fő- ( )
{
int * q = új int ( 70 ) ;
char * ch = reinterpret_cast ( q ) ;
cout << * q << endl ;
cout << * ch << endl ;
cout << q << endl ;
cout << ch << endl ;
Visszatérés 0 ;
}
Kezdetben egy egész számot rendelünk hozzá 70 értékkel. A q mutató erre a dinamikusan lefoglalt egészre mutat. A reinterpret_cast a q mutató ch karaktermutatóként való újraértelmezésére szolgál, ami azt jelenti, hogy az eredetileg q-hoz rendelt memóriát most úgy kezeli, mintha az egy karakter lenne. A cout paranccsal kiírja a q-hoz és ch-hez rendelt értéket. Mivel a ch karaktermutatóként van kezelve, karakterértéket ad vissza.
A ch-re mutató értéket *ch használatával írja ki. Mivel azonban a ch karaktermutatóként van kezelve, ez a sor karakterként értelmezi a memóriát. Kiírja a ch mutatóban tárolt memóriacímet a ch használatával. Ez ugyanaz a memóriacím, mint a q, mert ez csak ugyanazon memória újraértelmezése.
Kezdetben az egész szám tárolja a 70-et. Később ezt a q és ch mutató között manipulálják. A 2. és 4. kimenet ugyanaz, mert a második érték újraértelmezése a reinterpret_cast használatával történik.
jegyzet : Javasoljuk, hogy ne használja ezt az cast operátort addig, amíg nagy szükség nincs rá, mivel az objektumot nem hordozható termékké teszi
Következtetés
Az egyik változó adattípusának egy másikra való megváltoztatásának folyamatát típuskonverziónak vagy típusöntvénynek nevezik a C++ nyelven. Ez azért történik, hogy matematikai műveleteket hajtsanak végre a különböző adattípusok változóin azáltal, hogy azok adattípusait kompatibilissé teszik egymással. A típuskonverzió optimalizálja a kódot. A C++-ban vannak implicit és explicit típuskonverziók. Az implicit típuskonverziót maga a fordító hajtja végre egy előre meghatározott szabálykészlet segítségével, míg az explicit típuskonverziót a programozó hajtja végre hozzárendelési és cast operátorok segítségével.