Paano Mag-convert ng Mga Uri ng Data sa C++
Sa C++, mayroong dalawang paraan upang baguhin ang mga uri ng data:
Implicit Type Conversion
Ayon sa paunang natukoy na mga panuntunan ng C++ code compiler, ang implicit type na conversion ay ang uri ng conversion na isinasagawa ng compiler nang awtomatiko nang walang kinakailangan para sa anumang panlabas na trigger mula sa user. Ang ganitong uri ng conversion ay karaniwang nagaganap sa isang programa kapag mayroong higit sa isang uri ng data, at ang uri ng data ng expression ay hindi tumutugma sa uri ng data ng variable na kasangkot sa expression na ito.
Upang maiwasan ang pagkawala ng data sa panahon ng conversion, binago ng compiler bilang default ang mababang tumpak na uri ng data na may mas mataas na katumpakan ng uri ng data. Halimbawa, iko-convert nito ang isang integer sa isang float sa halip na baguhin ang float sa isang integer upang maiwasan ang pagkawala ng data. Ito ay tinatawag na promosyon. Ang sumusunod ay ang precedence diagram para sa iba't ibang uri ng data.
Order para sa Uri ng Conversion
Ang tamang pagkakasunud-sunod para sa uri ng conversion ay ibinibigay bilang:
bool -- > char -- > maikling int -- > int -- > unsigned int -- > mahaba-- > matagal na hindi pinirmahan -- > mahaba mahaba-- > lumutang -- > doble-- > mahabang doble
Ang mababang uri ng variable na katumpakan ay kino-convert sa mataas na katumpakan na uri ng data upang maiwasan ang pagkawala ng data.
Halimbawa 1
Sa halimbawang ito, isinagawa ang pagdaragdag sa variable ng iba't ibang uri ng data gamit ang implicit type na conversion.
#include
gamit namespace std ;
int pangunahing ( ) {
int numero = 100 ;
char karakter = 'C' ;
cout << '100 + 'C' = ' << numero + karakter << endl ;
lumutang val = numero + 'c' ;
cout << 'float val(100 + 'c') = ' << val << endl ;
int ay = 7890 ;
mahaba ay hindi = ay ;
cout << 'var_int =' << ay hindi ;
bumalik 0 ;
}
Narito ang isang integer at isang character mula sa ASCII table, at isang float number at character na 'c' ay idinagdag. Ang integer ay pinananatili sa ikatlong segment bilang isang mahabang uri ng data at ang mga uri ng data ay binago ng mismong compiler batay sa mga paunang natukoy na panuntunan nito.
Ang kabuuan ng 100 at 'C' ay nagbabalik ng 167 dahil ang 'C' ay katumbas ng 67 sa mga numero at ang 100+'c' ay nagbabalik ng 199 bilang ang maliit na titik na 'c' ay katumbas ng 99. Ang int variable ay nakaimbak sa isang mahabang uri ng data.
Halimbawa 2
Sa halimbawang ito, ang karakter D ay na-convert sa isang float upang maisagawa ang operasyon ng paghahati.
#includegamit namespace std ;
int pangunahing ( ) {
char x = 'D' ;
lumutang float_var ;
float_var = lumutang ( x ) / 'c' ;
// Tahasang nagko-convert ng int sa float.
cout << 'Ang halaga ng float_var ay: ' << float_var << endl ;
bumalik 0 ;
}
Ang input value ay nasa anyo ng character D na nakaimbak sa float data type at higit pang hinati sa character C. Ang mga character na ito ay binago sa mga numerical value at isang division operation ang ginagawa sa kanila, na ibinabalik ang value sa float.
Tiyak na Uri ng Conversion
Dapat manual na baguhin ng user ang uri ng data gamit ang tahasang uri ng conversion ng C++, na kadalasang kilala bilang type casting. Ginagawa ang ganitong uri ng pag-cast para maiwasan ang implicit na uri ng conversion. Mayroong dalawang mga paraan upang isagawa ang Explicit Type Casting sa C++:
- Conversion gamit ang Assignment Operator
- Conversion gamit ang Cast Operator
I-type ang Conversion gamit ang Assignment Operator sa C++
Ang pag-type ng conversion gamit ang Assignment Operator ay ginagawa nang pilit, iyon ay, ang isang uri ng data ay na-convert sa isa pa nang manu-mano. Nagagawa ito sa pamamagitan ng paggamit ng assignment operator na “=”, na nagtatalaga ng halaga ng right-hand operand sa variable sa kaliwang bahagi nito.
Halimbawa
Kinakalkula ng program na ito ang lugar ng bilog gamit ang uri ng casting.
#include
gamit namespace std ;
int pangunahing ( )
{
int radius ;
cout <> radius ;
lumutang lugar = M_PI * radius * radius ;
cout << 'Lugar ng bilog na may radius' << radius << '=' << lugar ;
}
Ginagamit ang assignment operator upang italaga ang float value sa lugar, na binubuo ng value ng radius sa integer data type.
Ang lugar ng bilog ay ibinalik sa float data type, habang ang radius ay input sa integer datatype. Kaya, ang uri ng data ng variable ay binago sa pamamagitan ng uri ng casting gamit ang assignment operator.
Uri ng Conversion Gamit ang Cast Operator sa C++
Ginagawa ang conversion ng uri sa pamamagitan ng paggamit ng cast operator, na pumipilit sa isang uri ng data na lumipat sa ibang uri ayon sa mga pangangailangan ng programa.
Mayroong apat na magkakaibang Cast Operator:
- static_cast
- const_cast
- dynamic_cast
- reinterpret_cast
1: static_cast
Ang static_cast ay ang casting operator na ginagamit upang tahasang i-convert ang mga float at character sa mga integer at iba pa. Ito ang pinakapangunahing operator ng cast. Maaari itong mag-cast ng mga uri ng data na magkatulad sa kalikasan. Maaari itong mag-convert ng mga pointer mula sa isang form patungo sa isa pa, kaya maaari rin itong magamit para sa pamamahala ng memorya.
Syntax
static_cast ( pagpapahayag ) Halimbawa
Ang program na ito ay binuo upang i-convert ang isang double variable sa isang int data type gamit ang static_cast. Puputulin nito ang anumang decimal na bahagi sa output.
gamit namespace std ;
int pangunahing ( )
{
// magdeklara ng variable
doble p ;
p = 2,905 * 1,235 * 24,675 ;
lumutang resulta ;
cout << ' Bago gamitin ang static na cast:' << endl ;
cout << ' Ang halaga ng p =' << p << endl ;
// gamitin ang static_cast upang i-convert ang uri ng data
resulta = static_cast ( p ) ;
cout << ' Pagkatapos gamitin ang static na cast: ' << endl ;
cout << ' Ang halaga ng resulta = ' << resulta << endl ;
bumalik 0 ;
}
Sa una, ang isang dobleng variable na p ay na-load ng mga halaga na pinarami ng bawat isa at nakaimbak sa resulta. Ang resulta ay naglalaman ng resulta bago at kasunod ng static_cast operator:
Bago gamitin ang static_cast operator, ang resulta ay ipinapakita sa mga decimal point, habang pagkatapos gamitin ang operator na ito ay ipinapakita ito sa integer na uri ng data.
2: const_cast
Ang const_cast operator ay ginagamit upang i-convert ang isang pare-parehong halaga ng isang bagay sa hindi pare-parehong uri. Ito ay ginagamit kung saan ang isang pare-parehong bagay ay ipinahayag, at kailangan nating baguhin ang halaga nito paminsan-minsan.
Syntax
const_cast ( pagpapahayag ) Halimbawa
Sa halimbawang ito, ginagamit ang const_cast operator upang pansamantalang tanggalin ang constant qualifier at pinapayagan ang paggawa ng mga pagbabago sa variable ayon sa pangangailangan:
gamit namespace std ;
int pangunahing ( ) {
const int x = 70 ;
const int * at = at x ;
cout << 'Ang lumang halaga ay' << * at << ' \n ' ;
int * Sa = const_cast ( at ) ;
* Sa = 90 ;
cout << 'Ang bagong halaga ay' << * at ;
bumalik 0 ;
}
Ang constant qualifier ay itinalaga sa isang int variable x na nangangahulugan na ang variable na ito ay hindi maaaring baguhin nang direkta. Pagkatapos na ang int *y na isang pointer ay ginagamit upang ma-access ang x, ngunit hindi pa rin ito mababago, at ang orihinal na halaga nito ay ipinapakita gamit ang cout. Gamit ang const_cast operator, ang isang pointer z ay nilikha na hindi pare-pareho, ito ay ginagamit upang ma-access ang halaga ng x na ginagawa itong nae-edit. Binabago nito ang halaga na itinalaga sa z na may 90 na hindi direktang nagbabago sa halaga sa x.
Sa una, ang halaga ng constant variable x ay 70 na binago sa pamamagitan ng paggamit ng const_cast operator, ginagawa itong 90.
3: dynamic_cast
na may hierarchy ng inheritance, na tinutukoy din bilang type-safe downcast. Ang down casting ay ang proseso ng pag-convert ng reference o pointer sa isang derived class mula sa base class reference o pointer.
Syntax
dynamic_cast ( pagpapahayag ) Halimbawa
Sa halimbawang ito, ang dynamic_cast operator ay ginagamit upang suriin ang uri ng polymorphic na klase, at nagbibigay-daan ito sa pag-access sa parehong base at derived na mga miyembro ng klase.
#include
gamit namespace std ;
klase TBase
{
pampubliko :
lumutang base_g = 9.81 ;
virtual walang bisa dummy ( )
{
} ;
} ;
klase Nakuha : pampubliko TBase
{
pampubliko :
int local_g = 9.78 ;
} ;
int pangunahing ( )
{
TBase * base = bago Nakuha ;
Nakuha * nagmula ;
nagmula = dynamic_cast ( base ) ;
cout < base_g << endl ;
cout < local_g << endl ;
getchar ( ) ;
bumalik 0 ;
}
Dalawang klase ang tinukoy bilang base at nagmula na mga klase. Ang isang pointer base ng uri ng TBase* ay ginawa at itinalaga sa isang dynamic na inilalaan na bagay na may uri ng TDerived. Ang isang derived class object ay maaaring italaga sa isang base class pointer sa pagkakataong ito ng polymorphism. Sinusuri ng dynamic_cast kung naa-access ng pointer ang wastong object ng TDerived, kung ang cast ay nakakuha ng matagumpay na resulta ang nagmula na klase ay makakakuha ng wastong resulta kung hindi ay magbabalik ito ng null value.
4: reinterpret_cast
Binabago ng reinterpret_cast ang isang pointer ng isang uri ng data sa isang pointer ng ibang uri ng data. Hindi nito sinusuri kung ang mga uri ng data ng mga pointer ay pareho o hindi. Ang casting operator na ito ay kailangang gamitin at maingat na hawakan.
Halimbawa
Sa paglalarawang ito, ang pointer ng isang uri ng data ay muling binibigyang kahulugan sa isang pointer ng isa pang uri ng data gamit ang reinterpret_cast:
gamit namespace std ;
int pangunahing ( )
{
int * q = bago int ( 70 ) ;
char * ch = reinterpret_cast ( q ) ;
cout << * q << endl ;
cout << * ch << endl ;
cout << q << endl ;
cout << ch << endl ;
bumalik 0 ;
}
Sa una, ang isang integer ay itinalaga na may halagang 70. Ang pointer q ay tumuturo sa dynamic na inilaan na integer na ito. Ang reinterpret_cast ay ginagamit upang muling bigyang-kahulugan ang pointer q bilang isang character pointer ch, na nangangahulugan na ang memorya na orihinal na itinalaga sa q ay itinuturing na ngayon bilang isang character. Gamit ang cout command, ini-print nito ang value na nakatalaga sa q at ch. Dahil ang ch ay itinuturing bilang isang pointer ng character, magbabalik ito ng isang halaga ng character.
Ito ay nagpi-print ng value na nakaturo sa ch gamit ang *ch. Gayunpaman, dahil ang ch ay itinuturing bilang isang pointer ng character, ang linyang ito ay magbibigay-kahulugan sa memorya bilang isang character. Ini-print nito ang memory address na nakaimbak sa pointer ch gamit ang ch. Ito ay ang parehong memory address bilang q dahil ito ay isang reinterpretasyon lamang ng parehong memorya.
Sa una, ang integer ay nag-iimbak ng 70. Nang maglaon, ito ay manipulahin sa pagitan ng pointer q at pointer ch. Ang mga output 2 at 4 ay pareho dahil ang pangalawang halaga ay muling binibigyang kahulugan gamit ang reinterpret_cast.
Tandaan : Iminumungkahi na huwag gamitin ang cast operator na ito hanggang sa at maliban kung kinakailangan dahil ginagawa nitong hindi portable na produkto ang bagay.
Konklusyon
Ang proseso ng pagbabago ng uri ng data ng isang variable patungo sa isa pa ay kilala bilang type conversion o type casting sa C++. Ginagawa ito upang magsagawa ng mga operasyong matematikal sa mga variable ng iba't ibang uri ng data, sa pamamagitan ng paggawa ng kanilang mga uri ng data na magkatugma sa isa't isa. Ino-optimize ng uri ng conversion ang code. May mga implicit at tahasang uri ng mga conversion sa C++. Implicit type conversion ay isinasagawa ng mismong compiler gamit ang isang paunang natukoy na hanay ng mga panuntunan, habang ang tahasang uri ng conversion ay isinasagawa ng programmer gamit ang mga assignment operator at cast operator.