Как да конвертирате типове данни в C++
В C++ има два начина за промяна на типовете данни:
Неявно преобразуване на типове
Съгласно предварително дефинираните правила от компилатора на C++ код, имплицитното преобразуване на тип е преобразуването на типа, извършено от компилатора автоматично, без изискване за външен тригер от потребителя. Този тип преобразуване обикновено се извършва в програма, когато има повече от един тип данни и типът данни на израза не съвпада с типа на данните на променливата, включена в този израз.
За да избегне загуба на данни по време на преобразуване, компилаторът по подразбиране променя типа данни с ниска точност с типа данни с по-висока точност. Например, той ще преобразува цяло число в плаващо число, вместо да променя числото с плаваща замък в цяло число, за да предотврати загуба на данни. Това се нарича промоция. Следва диаграмата на приоритета за различните типове данни.
Поръчка за преобразуване на типа
Правилният ред за преобразуване на типа е даден като:
bool -- > въглен -- > кратко вътрешно -- > int -- > неподписано int -- > дълго -- > без знак дълго -- > дълго дълго -- > плувам -- > двойно -- > дълъг двоен
Променливата тип данни с ниска точност се преобразува в тип данни с висока точност, за да се предотврати загуба на данни.
Пример 1
В този пример добавянето се извършва върху променливата на различни типове данни, като се използва имплицитното преобразуване на типа.
#include
използвайки пространство от имена std ;
вътр основен ( ) {
вътр номер = 100 ;
въглен характер = '° С' ;
cout << '100 + 'C' = ' << номер + характер << endl ;
плавам вал = номер + '° С' ;
cout << 'float val(100 + 'c') = ' << вал << endl ;
вътр беше = 7890 ;
дълго не беше = беше ;
cout << 'var_int =' << не беше ;
връщане 0 ;
}
Тук се добавят цяло число и символ от ASCII таблицата, както и число с плаваща замък и символ 'c'. Цялото число се съхранява в третия сегмент като дълъг тип данни и типовете данни се променят от самия компилатор въз основа на неговите предварително дефинирани правила.
Сумата от 100 и „C“ връща 167, тъй като „C“ се равнява на 67 в числа, а 100+ „c“ връща 199, тъй като малката буква „c“ се равнява на 99. Променливата int се съхранява в дълъг тип данни.
Пример 2
В този пример символът D се преобразува в плаващ елемент, за да се извърши операцията за деление.
#includeизползвайки пространство от имена std ;
вътр основен ( ) {
въглен х = 'Д' ;
плавам float_var ;
float_var = плавам ( х ) / '° С' ;
// Изрично преобразуване на int в float.
cout << 'Стойността на float_var е: ' << float_var << endl ;
връщане 0 ;
}
Входната стойност е под формата на символ D, който се съхранява в тип данни с плаваща задна буква и се разделя допълнително на символ C. Тези знаци се променят в числови стойности и върху тях се извършва операция за деление, връщаща стойността в плаваща единица.
Изрично преобразуване на типа
Потребителят трябва ръчно да промени типа данни с изричното преобразуване на типа на C++, често известно като преобразуване на типа. Този тип кастинг се прави, за да се избегне имплицитното преобразуване на типа. Има два метода за извършване на явно преобразуване на типове в C++:
- Преобразуване с помощта на оператора за присвояване
- Преобразуване с помощта на оператора Cast
Преобразуване на тип с помощта на оператора за присвояване в C++
Преобразуването на тип с помощта на оператора за присвояване се извършва принудително, т.е. един тип данни се преобразува ръчно в друг. Това се постига чрез използване на оператора за присвояване „=“, който присвоява стойността на десния операнд на променливата от лявата му страна.
Пример
Тази програма изчислява площта на кръга с помощта на отливане на типове.
#include
използвайки пространство от имена std ;
вътр основен ( )
{
вътр радиус ;
cout <> радиус ;
плавам ■ площ = M_PI * радиус * радиус ;
cout << 'Площ на кръг с радиус' << радиус << ' = ' << ■ площ ;
}
Операторът за присвояване се използва за присвояване на плаваща стойност на областта, която се състои от стойността на радиуса в целочислен тип данни.
Площта на кръга се връща в тип данни float, докато радиусът се въвежда в тип данни целочислен. По този начин типът данни на променливата се променя чрез преобразуване на типа с помощта на оператора за присвояване.
Преобразуване на типове с помощта на оператора Cast в C++
Преобразуването на тип се извършва с помощта на оператор за преобразуване, който принуждава един тип данни да се промени в друг тип според нуждите на програмата.
Има четири различни оператора за предаване:
- static_cast
- const_cast
- динамично_предаване
- reinterpret_cast
1: static_cast
Static_cast е операторът за кастинг, който се използва за изрично преобразуване на плаващи знаци и знаци в цели числа и т.н. Това е най-основният каст оператор. Може да прехвърля типове данни, които са сходни по природа. Може да конвертира указатели от една форма в друга, така че може да се използва и за управление на паметта.
Синтаксис
static_cast ( изразяване ) Пример
Тази програма е създадена да преобразува двойна променлива в int тип данни с помощта на static_cast. Той ще отреже всяка десетична част в изхода.
използвайки пространство от имена std ;
вътр основен ( )
{
// деклариране на променлива
двойно стр ;
стр = 2,905 * 1,235 * 24,675 ;
плавам резултат ;
cout << 'Преди да използвате статичното предаване:' << endl ;
cout << ' Стойността на p = ' << стр << endl ;
// използвайте static_cast за преобразуване на типа данни
резултат = static_cast ( стр ) ;
cout << ' След използване на статичното предаване: ' << endl ;
cout << ' Стойността на резултата = ' << резултат << endl ;
връщане 0 ;
}
Първоначално двойна променлива p се зарежда със стойности, които се умножават една по друга и се съхраняват в резултата. Резултатът съдържа резултата преди и след оператора static_cast:
Преди да използвате оператора static_cast, резултатът се показва в десетични точки, докато след използване на този оператор се показва в целочислен тип данни.
2: const_cast
Операторът const_cast се използва за преобразуване на постоянна стойност на обект в неконстантен тип. Използва се, когато е деклариран постоянен обект и трябва от време на време да променяме стойността му.
Синтаксис
const_cast ( изразяване ) Пример
В този пример операторът const_cast се използва за временно премахване на константния квалификатор и позволява извършване на промени в променливата според нуждите:
използвайки пространство от имена std ;
вътр основен ( ) {
конст вътр х = 70 ;
конст вътр * и = и х ;
cout << 'Старата стойност е ' << * и << ' \н ' ;
вътр * с = const_cast ( и ) ;
* с = 90 ;
cout << „Новата стойност е“ << * и ;
връщане 0 ;
}
Константният квалификатор се присвоява на int променлива x, което означава, че тази променлива не може да бъде модифицирана директно. След това int *y, който е указател, се използва за достъп до x, но все още не може да бъде променен и първоначалната му стойност се показва с помощта на cout. С помощта на оператора const_cast се създава указател z, който не е константен, той се използва за достъп до стойността на x, което го прави редактируем. Той променя стойността, присвоена на z с 90, което индиректно променя стойността в x.
Първоначално стойността на постоянната променлива x е 70, която се променя с помощта на оператора const_cast, което я прави 90.
3: динамично_предаване
с йерархията на наследяването, което също се нарича като безопасен за тип низходящ тип. Прехвърлянето надолу е процес на преобразуване на препратка или указател към производен клас от препратка или указател на базов клас.
Синтаксис
динамично_предаване ( изразяване ) Пример
В този пример операторът dynamic_cast се използва за проверка на типа на полиморфния клас и позволява достъп до базови и производни членове на класа.
#include <изключение>
използвайки пространство от имена std ;
клас TBase
{
публичен :
плавам база_g = 9.81 ;
виртуален невалиден манекен ( )
{
} ;
} ;
клас TИзведено : публичен TBase
{
публичен :
вътр local_g = 9,78 ;
} ;
вътр основен ( )
{
TBase * база = нов TИзведено ;
TИзведено * получени ;
получени = динамично_предаване ( база ) ;
cout < база_g << endl ;
cout < local_g << endl ;
getchar ( ) ;
връщане 0 ;
}
Два класа са дефинирани като базови и производни класове. Създава се база на указател от тип TBase* и се присвоява на динамично разпределен обект от тип TDerived. Обект на производен клас може да бъде присвоен на указател на базов клас в този случай на полиморфизъм. Dynamic_cast проверява дали указателят има достъп до валидния обект на TDerived, ако кастането получи успешен резултат, производният клас ще получи валиден резултат, в противен случай ще върне нулева стойност.
4: reinterpret_cast
Reinterpret_cast трансформира указател от един тип данни в указател от различен тип данни. Той не проверява дали типовете данни на указателите са еднакви или не. Този оператор за отливане трябва да се използва и борави внимателно.
Пример
В тази илюстрация указателят на един тип данни се преинтерпретира в указател на друг тип данни с помощта на reinterpret_cast:
използвайки пространство от имена std ;
вътр основен ( )
{
вътр * р = нов вътр ( 70 ) ;
въглен * гл = reinterpret_cast ( р ) ;
cout << * р << endl ;
cout << * гл << endl ;
cout << р << endl ;
cout << гл << endl ;
връщане 0 ;
}
Първоначално цяло число се присвоява със стойност 70. Указателят q сочи към това динамично разпределено цяло число. Reinterpret_cast се използва за повторно интерпретиране на указателя q като символен указател ch, което означава, че паметта, първоначално присвоена на q, сега се третира като знак. Използвайки командата cout, тя отпечатва стойността, присвоена на q и ch. Тъй като ch се третира като символен указател, той ще върне символна стойност.
Той отпечатва стойността, посочена към ch, използвайки *ch. Въпреки това, тъй като ch се третира като указател на символ, този ред ще интерпретира паметта като знак. Той отпечатва адреса на паметта, съхранен в указателя ch, използвайки ch. Това е същият адрес на паметта като q, защото е просто повторна интерпретация на същата памет.
Първоначално цялото число съхранява 70. По-късно това се манипулира между указателя q и указателя ch. Резултати 2 и 4 са еднакви, защото втората стойност се интерпретира повторно с помощта на reinterpret_cast.
Забележка : Препоръчва се да не използвате този оператор за прехвърляне, докато и освен ако не е много необходим, тъй като това прави обекта непреносим продукт
Заключение
Процесът на промяна на типа данни на една променлива в друга е известен като преобразуване на тип или преобразуване на тип в C++. Това се прави, за да се извършват математически операции върху променливите от различни типове данни, като се правят техните типове данни съвместими един с друг. Преобразуването на типа оптимизира кода. В C++ има неявни и явни преобразувания на типове. Неявното преобразуване на тип се извършва от самия компилатор с помощта на предварително дефиниран набор от правила, докато явното преобразуване на тип се извършва от програмиста с помощта на оператори за присвояване и оператори за преобразуване.