Программирование. Принципы и практика использования C++ Исправленное издание - Бьёрн Страуструп Страница 31

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

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

3.9.1. Безопасные преобразования

В разделе 3.4 мы видели, что нельзя непосредственно складывать объекты типа char или сравнивать объекты типов double и int. Однако в языке С++ это можно сделать косвенным образом. При необходимости объект типа char можно преобразовать в объект типа int, а объект типа int — в объект типа double. Рассмотрим пример.

char c = 'x';

int i1 = c;

int i2 = 'x';

Здесь значения переменных i1 и i2 равны 120, т.е. 8-битовому ASCII коду символа 'x'. Это простой и безопасный способ получения числового представления символа. Мы называем это преобразование типа char в тип int безопасным, поскольку при этом не происходит потери информации; иначе говоря, мы можем скопировать результат, хранящийся в переменной типа int, обратно в переменную типа char и получить исходное значение.

char c2 = i1;

cout << c << ' ' << i1 << ' ' << c2 << '\n';

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

x 120 x

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

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 < 0)        // перед сравнением число 0 преобразуется в число 0.0

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

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

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

 

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

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

int main()

{

  int a = 20000;

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

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

  int b = c;

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

    cout << "Ой!: " << a << "!=" << b << '\n';

  else

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

}

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

int main()

{

 double d = 0;

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

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

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

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

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

   cout << " d==" << d        // исходное значение типа double

   << " i==" << i             // преобразуется в значение типа int

   << " i2==" << i2           // целое значение переменной типа char

   << " char(" << c << ")\n"; // значение типа 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

int в char

int в bool

char в bool

 

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