Программирование. Принципы и практика использования C++ Исправленное издание, стр. 40

Этот фрагмент программы выводит на экран следующий результат:

x 120 x

В этом смысле — то, что значение всегда преобразуется в эквивалентное значение или (для типа

<b>double</b>
) в наилучшее приближение эквивалентного значения, — такие преобразования являются безопасными.

bool
в
char

bool
в
int

bool
в
double

char
в
int

char
в
double

int
в
double

Наиболее полезным является преобразование переменной типа

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

double d1 = 2.3;

double d2 = d1+2;  // перед сложением число преобразуется в число 2.0

if (d1 &lt; 0)        // перед сравнением число 0 преобразуется в число 0.0

  cout(&quot;d1 — отрицательно&quot;);

Для действительно больших чисел типа 

<b>int</b>
при их преобразовании в переменные типа 
<b>double</b>
мы можем (в некоторых компьютерах) потерять точность. Однако эта проблема возникает редко.

3.9.2. Опасные преобразования

 

Программирование. Принципы и практика использования C++ Исправленное издание - _003.png
 Безопасные преобразования обычно не беспокоят программистов и упрощают разработку программ. К сожалению, язык С++ допускает (неявные) опасные преобразования. Под опасными преобразованиями мы подразумеваем то, что значение может неявно превратиться в значение иного типа, которое не равно исходному.

Рассмотрим пример.

int main()

{

  int a = 20000;

  char c = a;  // попытка втиснуть большое значение типа int

               // в маленькую переменную типа char

  int b = c;

  if (a != b)  // != означает &quot;не равно&quot;

    cout &lt;&lt; &quot;Ой!: &quot; &lt;&lt; a &lt;&lt; &quot;!=&quot; &lt;&lt; b &lt;&lt; '\n';

  else

    cout &lt;&lt; &quot;Ого! Мы получили большие значения типа char\n&quot;;

}

Такие преобразования называют “сужающими”, поскольку они заносят значение в объект, размер которого слишком мал (“узок”) для их хранения. К сожалению, лишь некоторые компиляторы предупреждают об опасной инициализации переменной типа

char
значением переменной типа
int
. Проблема заключается в том, что тип
int
, как правило, намного больше типа
char
, так что он может (в нашем случае так и происходит) хранить значение типа
int
, которое невозможно представить как значение типа
char
. Попробуйте выяснить, чему равна переменная
b
на вашей машине (обычно должно получиться 32); поэкспериментируйте.

int main()

{

 double d = 0;

 while (cin&gt;&gt;d) {             // повторяем последующие инструкции,

                              // пока мы вводим целые числа

   int i = d;                 // попытка втиснуть double в int

   char c = i;                // попытка втиснуть int в char

   int i2 = c;                // получаем целое значение переменной типа char

   cout &lt;&lt; &quot; d==&quot; &lt;&lt; d        // исходное значение типа double

   &lt;&lt; &quot; i==&quot; &lt;&lt; i             // преобразуется в значение типа int

   &lt;&lt; &quot; i2==&quot; &lt;&lt; i2           // целое значение переменной типа char

   &lt;&lt; &quot; char(&quot; &lt;&lt; c &lt;&lt; &quot;)\n&quot;; // значение типа char

 }

}

Использованная в этой программе инструкция

while
позволяет ввести много значений (см. раздел 4.4.2.1).

ПОПРОБУЙТЕ

Выполните эту программу, вводя разные значения. Попробуйте ввести небольшие значения (например,

2
и
3
); большие значения (больше чем
127
, больше чем
1000
); отрицательные значения; введите число
56
;
89
;
128
; неотрицательные целые числа (например,
56.9
и
56.2
). Кроме демонстрации преобразования типа
double
в тип
int
и типа
int
в тип
char
на вашем компьютере, эта программа показывает, какое значение типа
char
выводится для заданного целого числа.

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

double
в
int

double
в
char

double
в
bool