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

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

Предположим, например, что переменная so_long имеет тип long, переменная thirty — тип short, а в программе присутствует следующий оператор:

so_long = thirty; // присваивание значения типа short переменной типа long

Программа принимает значение переменной thirty (обычно 16-битное) и расширяет его до значения long (обычно 32-битное) во время присваивания.

Проблемы при преобразовании чисел:

1. Больший тип с плавающей точкой в меньший тип с плавающей точкой, например, double в float – Потеря точности (значащих цифр); исходное значение может превысить диапазон, допустимый для целевого типа, поэтому результат окажется неопределенным.

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

3. Больший целочисленный тип в меньший целочисленный тип, например, long в short – Исходное значение может превысить диапазон, допустимый для целевого типа; обычно копируются только младшие байты.

Правила преобразования – операнд меньшего ранга преобразовывается в операнд высокого ранга!

Приведение типов

Чтобы преобразовать значение int, хранящееся в переменной по имени thorn, в тип long, можно использовать одно из следующих выражений:

(long) thorn // возвращает результат преобразования thorn в тип long

long (thorn) // возвращает результат преобразования thorn в тип long

В общих чертах можно делать следующее:

(имяТипа) значение II преобразует значение в тип имяТипа

имяТипа (значение) II преобразует значение в тип имяТипа

Первая форма представляет стиль С, а вторая — стиль C++.

Определение количества цифр после запятой в вещественном числе в выводе:

В заголовке: #include <iomanip>

В выводе: cout << setprecision(4) << a << endl; //например 10.53 – 2 знака после запятой, всего 4 знака!

а может 8.234 – тоже всего 4 знака!

Или

printf ("%.2f", ml); //указывается 2 знака после запятой! – 10.53 или 8.23 (не определяет общее число знаков

задача: принудительное изменение типов:сложить 19,99 и 11,99 – 1) результат должен быть int; 2) привести слагаемые к целому типу а потом сложить, результат должен быть int.

int a, b;

// следующий оператор суммирует значения типа double,

// а полученный результат преобразуется в тип int

a = 19.99 + 11.99;

// эти операторы суммируют целочисленные значения

b = int (19.99) + int (11.99); // новый синтаксис C++

cout << "a = " << a << ", b = " « b << endl;

Вот как выглядят результаты выполнения этой программы:

a = 31, b = 30

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

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 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