Како претворити типове података у Ц++
У Ц++-у постоје два начина за промену типова података:
Имплицитна конверзија типа
Према унапред дефинисаним правилима компајлера Ц++ кода, имплицитна конверзија типа је конверзија типа коју преводилац обавља аутоматски без потребе за било каквим спољним окидачем од корисника. Овај тип конверзије се обично одвија у програму када постоји више од једног типа података, а тип података израза не одговара типу података променљиве укључене у овај израз.
Да би се избегао губитак података током конверзије, компајлер подразумевано мења тип података ниске прецизности са типом података веће прецизности. На пример, он ће конвертовати цео број у флоат уместо да мења флоат у цео број да би спречио губитак података. Ово се зове промоција. Следи дијаграм приоритета за различите типове података.
Налог за конверзију типа
Тачан редослед за конверзију типа је дат као:
боол -- > цхар -- > кратки инт -- > инт -- > унсигнед инт -- > дуго -- > непотписано дуго -- > дуго дуго -- > пловак -- > дупло -- > дуга двострука
Променљива типа ниске прецизности се конвертује у тип података високе прецизности да би се спречио губитак података.
Пример 1
У овом примеру, сабирање се врши на променљивој различитих типова података коришћењем имплицитне конверзије типа.
#инцлуде <иостреам>
Користећи именског простора стд ;
инт главни ( ) {
инт број = 100 ;
цхар карактера = 'Ц' ;
цоут << '100 + 'Ц' = ' << број + карактера << ендл ;
пловак вал = број + 'ц' ;
цоут << 'флоат вал (100 + 'ц') = ' << вал << ендл ;
инт био = 7890 ;
дугачак није = био ;
цоут << 'вар_инт = ' << није ;
повратак 0 ;
}
Овде се додају цео број и знак из АСЦИИ табеле, као и број са пловком и знак „ц“. Цео број се чува у трећем сегменту као дугачак тип података, а типове података мења сам компајлер на основу својих унапред дефинисаних правила.
Збир 100 и 'Ц' враћа 167 јер је 'Ц' једнако 67 у бројевима, а 100+'ц' враћа 199 као мала слова 'ц' једнако 99. Променљива инт се чува у дугом типу података.
Пример 2
У овом примеру, знак Д се претвара у флоат да би се извршила операција дељења.
#инцлуде <иостреам>Користећи именског простора стд ;
инт главни ( ) {
цхар Икс = 'Д' ;
пловак флоат_вар ;
флоат_вар = пловак ( Икс ) / 'ц' ;
// Експлицитно претварање инт у флоат.
цоут << 'Вредност флоат_вар је: ' << флоат_вар << ендл ;
повратак 0 ;
}
Улазна вредност је у облику знака Д који се чува у флоат типу података и даље дели знаком Ц. Ови знакови се мењају у нумеричке вредности и на њима се врши операција дељења, враћајући вредност у флоат.
Експлицитна конверзија типа
Корисник мора ручно да промени тип података са експлицитном конверзијом типа у Ц++, често познатом као преливање типа. Овај тип кастинга се врши да би се избегла имплицитна конверзија типа. Постоје две методе за извођење експлицитног превођења типа у Ц++:
- Конверзија помоћу оператора доделе
- Конверзија помоћу Цаст Оператора
Тип Конверзија користећи Оператор доделе у Ц++
Конверзија типа помоћу Оператора доделе се врши принудно, то јест, један тип података се конвертује у други ручно. Ово се постиже коришћењем оператора доделе „=“, који променљивој са леве стране додељује вредност десног операнда.
Пример
Овај програм израчунава површину круга помоћу ливења типа.
#инцлуде <цматх>
Користећи именског простора стд ;
инт главни ( )
{
инт радијус ;
цоут <> радијус ;
пловак области = М_ПИ * радијус * радијус ;
цоут << 'Област круга са радијусом' << радијус << ' = ' << области ;
}
Оператор доделе се користи за додељивање флоат вредности области, која се састоји од вредности радијуса у целобројном типу података.
Подручје круга се враћа у флоат типу података, док се радијус уноси у целобројни тип података. Дакле, тип података променљиве се мења путем преливања типа помоћу оператора доделе.
Конверзија типа помоћу оператора Цаст у Ц++
Конверзија типа се врши коришћењем цаст оператора, који приморава један тип података да се промени у други тип у складу са потребама програма.
Постоје четири различита оператера Цаст:
- статиц_цаст
- цонст_цаст
- динамиц_цаст
- реинтерпрет_цаст
1: статиц_цаст
Статиц_цаст је оператор кастинга који се користи за експлицитно претварање флоат-а и знакова у целе бројеве и тако даље. Ово је најосновнији цаст оператор. Може да пребацује типове података који су по природи слични. Може да конвертује показиваче из једног облика у други, тако да се може користити и за управљање меморијом.
Синтакса
статиц_цаст ( израз ) Пример
Овај програм је направљен да конвертује двоструку променљиву у инт тип података користећи статиц_цаст. Одсече сваки децимални део у излазу.
Користећи именског простора стд ;
инт главни ( )
{
// декларишемо променљиву
дупло стр ;
стр = 2,905 * 1,235 * 24,675 ;
пловак резултат ;
цоут << ' Пре употребе статичког пребацивања:' << ендл ;
цоут << ' Вредност п = ' << стр << ендл ;
// користимо статиц_цаст за конверзију типа података
резултат = статиц_цаст ( стр ) ;
цоут << ' Након употребе статичког пребацивања: ' << ендл ;
цоут << ' Вредност резултата = ' << резултат << ендл ;
повратак 0 ;
}
У почетку, двострука променљива п се учитава вредностима које се међусобно множе и чувају у резултату. Резултат садржи резултат пре и после оператора статиц_цаст:
Пре употребе оператора статиц_цаст, резултат се приказује у децималним зарезима, док се након употребе овог оператора приказује у целобројном типу података.
2: цонст_цаст
Цонст_цаст оператор се користи за претварање константне вредности објекта у неконстантни тип. Користи се тамо где је декларисан константни објекат и повремено треба да променимо његову вредност.
Синтакса
цонст_цаст ( израз ) Пример
У овом примеру, оператор цонст_цаст се користи да привремено уклони квалификатор константе и омогућава измене у променљивој према потреби:
Користећи именског простора стд ;
инт главни ( ) {
конст инт Икс = 70 ;
конст инт * и = & Икс ;
цоут << 'Стара вредност је' << * и << ' \н ' ;
инт * Витх = цонст_цаст ( и ) ;
* Витх = 90 ;
цоут << 'Нова вредност је' << * и ;
повратак 0 ;
}
Квалификатор константе је додељен инт променљивој к што значи да се ова променљива не може директно модификовати. Након тога инт *и који је показивач се користи за приступ к, али се и даље не може променити, а његова оригинална вредност се приказује помоћу цоут. Користећи цонст_цаст оператор, креира се показивач з који није константан, користи се за приступ вредности к што га чини уређивањем. Он мења вредност додељену з са 90 што индиректно мења вредност у к.
У почетку, вредност константне променљиве к је 70 која се модификује коришћењем оператора цонст_цаст, чинећи је 90.
3: динамиц_цаст
са хијерархијом наслеђивања, која се такође назива спуштањем безбедног типа. Пребацивање наниже је процес претварања референце или показивача у изведену класу из референце или показивача основне класе.
Синтакса
динамиц_цаст ( израз ) Пример
У овом примеру, динамиц_цаст оператор се користи за проверу типа полиморфне класе и омогућава приступ и основним и изведеним члановима класе.
#инцлуде <изузетак>
Користећи именског простора стд ;
класа ТБасе
{
јавности :
пловак басе_г = 9.81 ;
виртуелни празнина думми ( )
{
} ;
} ;
класа ТДеривед : јавности ТБасе
{
јавности :
инт лоцал_г = 9.78 ;
} ;
инт главни ( )
{
ТБасе * база = Нова ТДеривед ;
ТДеривед * изведено ;
изведено = динамиц_цаст ( база ) ;
цоут < басе_г << ендл ;
цоут < лоцал_г << ендл ;
гетцхар ( ) ;
повратак 0 ;
}
Две класе су дефинисане као основне и изведене класе. База показивача типа ТБасе* се креира и додељује динамички додељеном објекту типа ТДеривед. Изведени објекат класе може се доделити показивачу основне класе у овом случају полиморфизма. динамиц_цаст проверава да ли показивач приступа важећем објекту ТДеривед, ако цаст добије успешан резултат, изведена класа ће добити валидан резултат, иначе ће вратити нулту вредност.
4: реинтерпрет_цаст
Реинтерпрет_цаст трансформише показивач једног типа података у показивач другог типа података. Не проверава да ли су типови података показивача исти или не. Овај оператер за ливење треба пажљиво користити и њиме се рукује.
Пример
На овој илустрацији, показивач једног типа података се реинтерпретира у показивач другог типа података помоћу реинтерпрет_цаст:
Користећи именског простора стд ;
инт главни ( )
{
инт * к = Нова инт ( 70 ) ;
цхар * гл = реинтерпрет_цаст ( к ) ;
цоут << * к << ендл ;
цоут << * гл << ендл ;
цоут << к << ендл ;
цоут << гл << ендл ;
повратак 0 ;
}
У почетку се додељује цео број са вредношћу 70. Показивач к показује на овај динамички додељен цео број. Реинтерпрет_цаст се користи за реинтерпретацију показивача к као показивача карактера цх, што значи да се меморија која је првобитно додељена к сада третира као да је знак. Користећи команду цоут, штампа вредност додељену к и цх. Пошто се цх третира као показивач карактера, он ће вратити вредност знака.
Штампа вредност указану на цх користећи *цх. Међутим, пошто се цх третира као показивач карактера, ова линија ће тумачити меморију као знак. Штампа меморијску адресу сачувану у показивачу цх користећи цх. Ово је иста меморијска адреса као к јер је то само реинтерпретација исте меморије.
У почетку, цео број чува 70. Касније се овим манипулише између показивача к и показивача цх. Излази 2 и 4 су исти јер се друга вредност реинтерпретира помоћу реинтерпрет_цаст.
Белешка : Предлаже се да се овај цаст оператор не користи све док и осим ако то није потребно јер објекат чини непреносивим производом
Закључак
Процес промене типа података једне променљиве у другу познат је као конверзија типа или преливање типа у Ц++. Ово се ради да би се извршиле математичке операције над варијаблама различитих типова података, тако што су њихови типови података међусобно компатибилни. Конверзија типа оптимизује код. У Ц++ постоје имплицитне и експлицитне конверзије типова. Имплицитну конверзију типа спроводи сам компајлер користећи унапред дефинисани скуп правила, док експлицитну конверзију типа спроводи програмер користећи операторе додељивања и цаст операторе.