Меню

Преобразувания на тип в C ++

type conversions c

Опитайте Нашия Инструмент За Премахване На Проблемите

Вижте различните преобразувания на типове, поддържани в C ++.

Надяваме се, че трябва да сте наясно с всички типове данни, които са налични в C ++ от нашите по-ранни уроци. Понякога може да възникне такава нужда, че да се наложи да преобразуваме един тип в друг. Това се нарича преобразуване на типа или преливане на тип.

В този урок ще обсъдим различните преобразувания на типове, поддържани в C ++.

въпроси, които да зададете на бизнес анализатор

=> Щракнете тук за безплатния курс C ++.

Преобразувайте тип в C ++

Какво ще научите:

Преобразувания на типа

C ++ поддържа два типа преобразувания на типове:

  • Неявно преобразуване на типа: Неявното преобразуване на типа е автоматично. При този тип преобразуване няма намеса от страна на потребителя и компилаторът директно извършва преобразуването. Преобразуването обикновено се извършва, когато в израза има повече от един тип данни. Но като цяло при този тип преобразуване съществува възможност за загуба на данни, загуба на знаци или преливане на данни.
  • Изрично преобразуване на тип: Изричното преобразуване на типа е дефинирано от потребителя и обикновено се нарича „преливане на тип“. Тук потребителят излъчва или преобразува стойност от един тип данни в друг в зависимост от изискванията. Този тип преобразувания са по-безопасни.

Сега ще видим и двата вида преобразуване на типа в детайли.

Неявно преобразуване

При неявно преобразуване компилаторът извършва преобразуванията от един тип данни в друг, когато израз има повече от един тип данни. За да се предотврати загуба на данни, всички променливи от другите типове данни се преобразуват в най-големия тип данни. Това се нарича повишение.

Нека разберем неявното преобразуване, използвайки пример за код.

#include using namespace std; int main() { int num = 10; char ch = 'A'; cout<<'10 + 'A' = '<

float val (10 + ‘a’) = 107

var_int = 1000

Горният пример на код демонстрира неявно преобразуване. Декларирали сме цяло число и променлива със знаци съответно със стойности 10 и „A“. Когато съберем тези две променливи, се извършва неявно преобразуване.

Тъй като цяло число е по-големият тип в този израз, стойността на символната променлива ‘A’ се преобразува в нейния цяло число еквивалент, т.е. стойност 65 (ASCII стойност). По този начин резултатът от израза е 75.

В следващия израз добавяме цяло число и символ (‘a’ -> 97) и след това присвояваме резултата да плава. По този начин резултатът от израза имплицитно се преобразува в float от компилатора.

В третия израз, кратка int променлива се преобразува в цяло число имплицитно.

Забележка : В случай на неявни преобразувания, ако компилаторът открие потенциална загуба на данни, тогава може да мига предупреждение за това.

Изрично преобразуване

Изричното преобразуване е известно още като „преливане на тип“, тъй като ние „прехвърляме“ един тип данни в друг тип данни. Тук потребителите изрично дефинират отливката, за разлика от неявното преобразуване, когато компилаторът извършва преобразуването вътрешно.

Можем да извършим явно преобразуване по два начина:

# 1) Използване на оператор за присвояване

Изрично преобразуване или типово излъчване с помощта на оператор за присвояване по начин се извършва принудително. Тук прехвърляме или преобразуваме един тип данни в друг тип данни, като използваме оператора за присвояване.

Общият синтаксис е:

(data type) expression;

Следният пример обяснява това:

#include #include using namespace std; int main() { int sum; double salary = 4563.75; sum = (int)salary + 1000; cout<<'Sum = '<# 2) Използване на Cast Operator

При този тип кастинг ние използваме „оператор на гласове“, който е унарен оператор за смяна от един тип на друг.

Видове леене

Имаме следните видове отливки в зависимост от оператора на гласове, който използваме:

# 1) Статичен актьорски състав

Статичният глас е най-простият сред всички излъчвания на типове, използвайки оператора за гласове . Статичният глас е в състояние да изпълнява всички преобразувания, които се извършват имплицитно. Той също така извършва преобразувания между указатели на класове, свързани помежду си (upcast -> от производно към база или downcast -> от база към производно).

Освен гореизброените преобразувания, статичното излъчване може също да преобразува всеки указател в void *.

Статичният глас е компилираният времеви състав. Това означава, че не е извършена проверка по време на изпълнение, за да се види дали изпълненият каст е валиден или не. По този начин остава отговорност на програмиста да гарантира, че преобразуването е безопасно и валидно.

С други думи, потребителят трябва да се увери, че преобразуваният обект е пълен по отношение на типа данни на местоназначението.

Ние посочваме статичен глас, както следва:

static_cast (expression)

Нека разберем статичния състав, използвайки пример.

#include using namespace std; int main() { double df = 3.5 * 3.5 * 3.5; cout<<'Before casting: df = '<

В горния пример леко сме модифицирали кода, за да включим символна променлива със стойност „A“. След това декларираме целочислен указател и прилагаме статичен глас за преобразуване на символ в целочислен указател.

Когато компилираме тази програма, получаваме следния изход.

Във функция ‘int main ()’:
10:35: грешка: невалиден static_cast от тип ‘char *’ до тип ‘int *’

Програмата дава грешка за статичното изпълнение, тъй като е невалидна. По този начин статичното излъчване позволява само валидно преливане на типове или преобразувания и дава грешка, когато се опитаме да извършим някакво нежелано излъчване на типове.

# 2) Динамичен актьорски състав

Динамичното гласуване е изпълнение по време на изпълнение, за да се провери валидността на гласовете. Динамичното гласуване се изпълнява само върху указатели на класове и референции. Изразът връща NULL стойност, ако гласът не успее.

Динамичният глас използва механизъм, известен като RTTI (Runtime Type Identification) . RTTI прави цялата информация за типа данни на обекта достъпна по време на изпълнение и е достъпна само за класовете, които имат поне една виртуална функция (полиморфен тип). RTTI позволява определяне на типа обект по време на изпълнение или по време на изпълнението.

java копира 2d масив в друг масив

Нека опитаме един пример, за да разберем динамичния актьорски състав.

#include #include using namespace std; class base {public: virtual void print(){}}; class derived:public base{}; int main() { base* b = new derived; derived* d = dynamic_cast(b); if(d != NULL) cout<<'Dynamic_cast done successfully'; else cout<<'Dynamic_cast not successful'; }

В тази програма дефинирахме два класа, base с виртуална функция и извлечени с базов клас, base.

В основната функция създаваме производен обект на клас, посочен от указателя на базовия клас. След това изпълняваме dynamic_cast на основния указател, сочейки към производен клас, за да го прехвърлим към указател на производен клас.

Както и в базовия клас, основата е полиморфна (съдържа виртуална функция), Dynamiccast е успешен.

Забележка: Ако премахнем виртуалната функция от горния клас, тогава dynamic_cast ще се провали, тъй като RTTI информация за обектите няма да бъде налична.

Динамичният актьорски състав има допълнителни разходи за безопасност на типа по време на изпълнение.

# 3) Преинтерпретирайте ролите

Този тип гласове е най-опасен за използване, тъй като работи върху всякакъв тип обект, без класовете да са свързани помежду си.

Reintepret_cast работи върху всякакви указатели и преобразува указател от всякакъв тип във всеки друг тип, независимо дали указателите са свързани помежду си или не. Той не проверява дали указателят или данните, към които сочи указателят, са еднакви или не.

Операторът за гласуване приема само един параметър, указателя на източника, за да конвертира и не връща никаква стойност. Той просто преобразува типа на показалеца.

Не трябва да използваме, освен ако не се изисква. Обикновено въвеждаме указателя на източника към оригиналния му тип.

Използваме най-вече за работа с битове. Когато се използва за булеви стойности, булевите стойности се преобразуват в цели числа, т.е. 1 за true и 0 за false.

Нека видим пример за преинтерпретиране на гласове:

#include using namespace std; int main() { int* ptr = new int(97); char* ch = reinterpret_cast(ptr); cout << ptr << endl; cout << ch << endl; cout << *ptr << endl; cout << *ch << endl; return 0; }

Изход:

0x3ef3090
да се
97
да се

В горния пример декларирахме целочисления указател ptr, сочещ към стойност 97. След това декларираме указател на символи ch и хвърляме ptr към него, използвайки.

След това отпечатваме различни стойности. Първият, който отпечатваме, е ptr, който сочи към цяло число. Следователно отпечатва адрес.

Следващата стойност ch съдържа стойност 97 и по този начин отпечатва „a“, което е ASCII еквивалент на 97. Следващата стойност „* ptr“ съдържа стойността 97, докато „* ch“ съдържа ASCII еквивалент на 97, т.е. преинтерпретираното_предаване.

# 4) Const Cast

Операторът за гласове се използва за промяна или манипулиране на стегнатостта на указателя на източника. Под манипулация имаме предвид, че може да бъде или да зададете constness на non-const указател, или да премахнете constness от const указател.

как да напиша ръчни тестови случаи с пример

Условието за успешно прехвърляне на оператора е указателят и източникът, който се предава, да бъдат от един и същи тип.

Нека вземем пример, за да разберем това.

#include using namespace std; int printVal(int* ptr) { return(*ptr*10); } int main(void) { const int value = 10; const int *ptr = &value; int *ptr_cast = const_cast (ptr); cout <<'printVal returned = '<< printVal(ptr_cast); return 0; }

В този пример виждаме, че функцията ‘printVal’ приема указател, който не е const. В основната функция имаме const променлива ‘value’, присвоена на const указателя ptr.

За да предадем този указател const на функцията printVal, ние го хвърляме чрез прилагане, за да премахнем constness. След това предаваме показалеца ptr_cast на функцията, за да получим желаните резултати.

Заключение

С това ще завършим тази тема за преобразуване на типове в C ++. Видяхме всичко за неявни и явни преобразувания, които се използват в C ++.

Трябва обаче да се знае, че за да се предотврати загуба на данни и други подобни трудности, преобразуването или типовото излъчване трябва да се прилагат разумно само ако ситуацията налага използването.

=> Внимавайте тук за ръководството за обучение за начинаещи C ++.

Препоръчително четене

^