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

Когда, мы что-либо делаем, нам, несомненно, важно знать каков будет результат. Вполне очевидно, что из тех ингредиентов из которых, скажем вариться суп харчо, вряд ли можно приготовить торт со взбитыми сливками. Следовательно, результат напрямую зависит, от составных частей. То же самое происходит с переменными. Если, скажем, складывается два числа типа int, вполне понятно, что результат так же будет иметь тип int. А вот как быть, если данные имеют разные типы? Именно об этом мы и поговорим в текущем разделе данного урока.

Итак, прежде всего, давайте разберемся с тем, как типы данных взаимодействуют друг с другом. Существует так называемая иерархия типов, где все типы размещены по старшинству. Для того, что бы разбираться в преобразовании типов, необходимо всегда помнить порядок типов этой иерархии.

bool,char,short-int-unsigned int-long-unsigned long-float-double-long double

Несмотря на то, что некоторые типы имеют одинаковый размер, в них помещается разный диапазон значений, например, unsigned int в отличие от int может поместить в себя в два раза больше положительных значений, и потому является старше по иерархии, при этом оба типа имеют размер 4 байта. Кроме того, следует отметить, очень важную особенность, отраженную здесь, если в преобразовании типов участвуют такие типы, как bool,char,short, они автоматически преобразовываются к типу int.

Теперь, давайте рассмотрим, различные классификации преобразований.

Классификация по диапазону содержащихся значений.

Все преобразования можно разделить на две группы относительно местоположения в иерархии типов участвующих в преобразовании.

1. Сужающее преобразование – при таком преобразовании - больший тип данных в иерархии преобразуется к меньшему типу, безусловно, в этом случае может произойти потеря данных, поэтому с сужающим преобразованием, следует быть осторожными. Например:

int A=23.5;
cout<<A; // на экране 23

Как видите, такое преобразование от double к int, ведет к грубому обрезанию вещественного числа, без математического округления, результатом которого являлось бы число 24.

2. Расширяющее преобразование. Данный вид преобразования, ведет к так называемому расширению типа данных от меньшего диапазона значений к большему диапазону. В качестве примера предлагается такая ситуация.

unsigned int a=3000000000;
cout<<a; // на экране 3000000000

В данном случае 3000000000 - это литерал типа int, который благопоучно расширяется до unsigned int, что и позволяет нам увидеть на экране именно 3000000000, а не что-то другое. Тогда, как в обычный int такое число не поместиться.

Классификация по способу осуществления преобразования.

Вне зависимости от направления преобразования, оно может быть осуществлено одним из двух способов.

1. Неявное преобразование. Все вышеописанные примеры относились к этому типу преобразования. Такой вид преобразования также называют автоматическим, т. к. оно происходит автоматически без вмешательства программиста, другими словами, мы ничего не делаем для того, что бы оно произошло.

float A=23,5; - double стал float без каких-либо дополнительных действий

2. Явное преобразование. (второе название – приведение типов). В данном случае, преобразование производится программистом, тогда, когда это необходимо. Давайте рассмотрим простой пример такого действия:

double z=37.4;
float y=(int) z;
cout<<z<<”*** ”<<y; // на экране 37.4 ***37

(int)z – есть явное сужающее преобразование от типа double к типу int. В этой же строке происходит расширяющее неявное преобразование от полученного типа int к типу float. Следует запомнить, что любое преобразование носит временный характер и действует только в пределах текущей строки. То есть переменная z как была double, так и останется на протяжении всей программы, а ее преобразование в int носило временный характер.

Преобразование типов в выражении.

И, вот, мы наконец-то подошли к тому, о чем говорили в самом начале данного раздела урока, как выяснить какого типа будет результат какого-то выражения. Давайте попробуем это вычислить, пользуясь полученными знаниями. Предположим у нас есть следующие переменные:

int I=27;
short S=2;
float F=22.3;
bool B=false;

Пользуясь этими переменными, мы собираемся составить такое выражение:

I-F+S*B

В переменную какого типа данных нам следует записать результат? Решить это просто, если представить выражение в виде типов данных:

int-float+short*bool

Напоминаем, что short и bool сразу же примут тип int, так что выражение будет выглядеть так:

int-float+int*int, при этом false станет 0

Умножение int на int даст, несомненно, результат типа int. А вот сложение float с int, даст на выходе float, так как, здесь вступает в игру новое правило:

Если в каком-либо выражении используются разные типы данных, то результат, приводится к большему из этих типов.

Ну и, наконец – вычитание из int типа float, согласно только что упомянутому правилу снова даст float.

Таким образом, результат выражения будет иметь тип float.

float res= I-F+S*B; // 27-22.3+2*0
cout<<res; // на экране число 4.7

Теперь, когда вы знакомы с правилом, вам нет необходимости, детально разбирать выражение, достаточно просто найти наибольший тип, именно он и будет результирующим.

Пример, использующий преобразование типов.

Теперь давайте закрепим знания на практике. Создадим проект и напишем нижеследующий код.

# include <iostream>
using namespace std;
void main(){

 // объявление переменных и запрос на ввод данных
 float digit;
 cout<<"Enter digit:";
 cin>>digit;

 /* Даже, если пользователь ввел число с вещественной частью,
 результат выражения запишется в int и вещественная часть будет утеряна,
 разделив число на 100 мы получим количество сотен в нем. */ 
 int res=digit/100;
 cout<<res<<" hundred in you digit!!!\n\n";
}

Теперь, когда вы рассмотрели пример, вы, конечно же, убедились, что c помощью преобразования типов можно не просто организовать временный переход из одного типа в другой, но и решить простую логическую задачу. Следовательно, вы должны отнестись к этой теме с должным вниманием. Понимание преобразования в дальнейшем поможет вам не только решать интересные задачи, но избежать ненужных ошибок.