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

  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

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

 double x = 2.7;
// какой-то код
 int y = x; // значение переменной y становится равным 2

С момента определения переменной y вы могли забыть, что переменная x имеет тип double, или упустить из виду, что преобразование double в int приводит к усечению (округлению вниз). Результат вполне предсказуем: семь десятых потеряны. Преобразование int в char не порождает проблем с усечением — ни тип int, ни тип char невозможно представить в виде дробной части целого числа. Однако переменная типа char может хранить только очень небольшие целые числа. В персональных компьютерах переменная типа char занимает 1 байт, в то время как переменная типа int — 4 байта.

Итак, мы не можем записать большое число, например 1000, в переменную типа char без потери информации: значение “сужается”. Рассмотрим пример.

 int a = 1000;
 char b = a; // переменная b становится равной –24

Не все значения типа int эквивалентны значению типа char. Точный диапазон значения типа char зависит от конкретной реализации. На персональных компьютерах значения типа char колеблются в диапазоне [–128:127], но мобильность программ можно обеспечить только в диапазоне [0:127], поскольку не каждый компьютер является персональным, и на некоторых из них значения типа char лежат в диапазоне [0:255].

Почему люди смирились с проблемой суживающих преобразований? Основная причина носит исторический характер: язык С++ унаследовал суживающие преобразования от предшественника, языка С. К первому дню существования языка С++ уже было множество программ, написанных на языке С и содержащих суживающие преобразования. Кроме того, многие такие преобразования на самом деле не создают никаких проблем, поскольку используемые значения не выходят за пределы допустимых диапазонов, и многие программисты жалуются, что “компиляторы указывают им, что надо делать”. В частности, опытные программисты легко справляются с проблемой опасных преобразований в небольших программах. Однако в более крупных программах и для неопытных программистов это может стать источником ошибок. Тем не менее компиляторы могут предупреждать программистов о суживающих преобразованиях — и многие из них делают это.

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

Задание

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

1. Напишите программу, формирующую простую форму для письма на основе входной информации. Для начала наберите программу из раздела 3.1, предложив пользователю ввести свое имя и предусмотрев вывод строки “Hello, first_name”, где first_name — это имя, введенное пользователем. Затем модифицируйте программу следующим образом: измените приглашение на строку “Введите имя адресата” и измените вывод на строку “Dear first_name,”. Не забудьте о запятой.