В каких случаях следует использовать типы short и long
Начинающим программистам часто бывает трудно принять решение о том, когда объявлять переменную с использованием типа long, а когда - с использованием типа short. Правило довольно простое: если существует хоть малейший шанс, что ваше значение будет слишком большим для предполагаемого типа, используйте тип с большим размером.
Приведенные в табл. 3.1 переменные типа unsigned short int, как правило, имеют размер, равный двум байтам, и могут хранить значение, не превышающее 65 535. Знаковые короткие целые делят свой диапазон между положительными и отрицательными числами, поэтому их максимальное значение вдвое меньше, чем у беззнакового короткого целого.
Хотя переменные типа unsigned long int могут хранить очень большое число (4 294 967 295), оно все-таки конечно. Если вам нужно работать с еще большими числами, придется перейти к использованию типов float или double, но при этом вы несколько проиграете в точности. Переменные типа float и double могут хранить чрезвычайно большие числа, но на большинстве компьютеров значимыми остаются только первые 7 или 19 цифр, т.е. после указанного количества цифр число округляется.
Переменные с меньшим размером используют меньший объем памяти. В наши дни память становится все дешевле, а жизнь не так уж длинна, чтобы тратить ее на экономию памяти. Поэтому отдайте предпочтение типу int, который на большинстве компьютеров имеет размер в четыре байта.
Переполнение беззнаковых целых
Что случится, если при использовании беззнаковых длинных целых превысить их предельный максимум?
Когда беззнаковое целое достигает своего максимального значения, при очередном инкременте оно сбрасывается в нуль и отсчет начинается сначала, как в автомобильном одометре. В листинге 3.4 показано, что произойдет при попытке поместить слишком большое число в переменную типа short.
Листинг 3.4. Пример переполнения беззнаковой целой переменной.
1: #include <iostream.h>
2: int main()
3: {
4: unsigned short int smallNumber;
5: smallNumber = 65535;
6: cout << "small number:" << smallNumber << endl;
7: smallNumber++;
8: cout << "small number:" << smallNumber << endl;
9: smallNumber++;
10: cout << "small number:" << smallNumber << endl;
11: return 0;
12: }
Результат:
small number:65535
small number:0
small numbar:1
АНАЛИЗ: В строке 4 объявляется переменная smallNumber типа unsigned short int, которая на моем компьютере является двухбайтовой, способной хранить значение между 0 и 65 535. В строке 5 переменной smallNumber присваивается максимальное значение, которое в строке 6 выводится на экран.
В строке 7 переменная smallNumber увеличивается на 1. Приращение осуществляется с помощью оператора инкремента, имеющего вид двух символов плюс (++). Следовательно, значение переменной smallNumber должно стать 65 536. Однако переменная типа unsigned short int не может хранить число, большее 65 535, поэтому ее значение сбрасывается в 0, который и выводится в строке 8.
В строке 9 переменная smallNumber вновь увеличивается на единицу, после чего ее новое значение выводится на экран.
Переполнение знаковых целочисленных значений
Знаковые целые отличаются от беззнаковых тем, что половина этих значений всего диапазона - отрицательные числа. При выходе за пределы максимального положительного значения переменная принимает минимальное отрицательное значение. В листинге 3.5 показано, что происходит, если добавить единицу к максимальному положительному числу, хранящемуся в переменной типа short int.
Листинг 3.5. Пример переполнения знаковой целой переменной
1: #include <iostream.h>
2: int main()
3: {
4: short int smallNumber;
5: smallNumber = 32767;
6: cout << "small number:" << smallNumber << endl;
7: smallNumber++;
8: cout << "small number:" << smallNumber << endl;
9: smallNumber++;
10: cout << "small number:" << smallNumber << endl;
11: return 0;
12:}
Анализ: В строке 4 переменная smallNumber объявляется на этот раз короткой целой (short int) со знаком (если в объявлении переменной ключевое слово unsigned отсутствует, т.е. эта переменная явно не объявляется беззнаковой, то подразумевается ее использование со знаком). В остальном эта программа выполняет те же действия, что и предыдущая, но на экран выводятся совсем другие результаты. Чтобы до конца понять, почему получены именно такие результаты, нужно знать, как представляются числа со знаком в двухбайтовом целом значении.
Этот пример показывает, что в случае приращения максимального положительного целого числа со знаком будет получено не нулевое значение (как в случае с беззнаковыми целыми), а минимальное отрицательное число.
Символы
Символьные переменные (типа char) обычно занимают один байт, этого достаточно для хранения 256 значений печатаемых символов (см. приложение В). Значение типа char можно интерпретировать как число в диапазоне 0-255, или символ ASCII. Набор символов ASCII и его эквивалент ISO (International Standards Organization - Международная организация по стандартизации) представляют собой способ кодировки всех букв, цифр и знаков препинания.
Например, в коде ASCII английской строчной букве "а" присвоено значение 97. Всем прописным и строчным буквам, всем цифрам и знакам препинания присвоены значения от 1 до 128. Дополнительные 128 знаков и символов зарезервированы для расширения возможностей компьютера, хотя расширенный набор символов IBM стал уже чем-то вроде стандарта.
Примечание:ASCII обычно произносится как "аскей".
Примечание:Компьютеры не имеют ни малейшего понятия, ни о каких буквах, знаках препинания или предложениях. Все они понимают только числа. В действительности же они оценивают некоторые электрические параметры в определенных точках своих схем. Если значение оцениваемого параметра выше некоторой оговоренной величины, оно представляется внутренне как 1, если нет - как 0. Путем группирования нулей и единиц компьютер способен генерировать кодовые комбинации, которые можно интерпретировать как числа, а те, в свою очередь, можно присвоить буквам и знакам препинания.
Символы и числа
Если поместить какой-нибудь символ, например "а", в переменную типа char, то в действительности она будет хранить число, лежащее в диапазоне между 0 и 255. Однако компилятор знает, как переходить от символов к их цифровым эквивалентам в ASCII и обратно.
Взаимосвязь между числом и буквой произвольна, поскольку нет никакой весомой причины для присваивания строчной букве "а" именно значения 97. Если все составляющие компьютера (ваша клавиатура, компилятор и экран) с этим "согласны", никаких проблем не возникнет. Однако важно понимать, что между значением 5 и символом "5" большая разница. Символу "5" в действительности соответствует значение 53, так же как букве "а" соответствует число 97.
Листинг 3.6. Вывод на зкран символов по их значениям.
1: #include <iostream.h>
2: int main()
3: {
4: for (int i = 32; i<128; i++)
5: cout << (char) i;
6: return 0;
7: }
Результат:
!"#$%'()*+,./0123456789:;<>?@ABCDEFGHIJKLMNOP
_QRSTUVWXYZ[\]"`abcdefghijklmnopqrstuvwxyz{|{~
Эта простая программа выводит символы, значения которых лежат в диапазоне 32-127.
Специальные символы
Компилятор C++ распознает некоторые специальные символы, предназначенные для форматирования текста. (Самые распространенные из них представлены в табл. 3.2.) Чтобы вставить эти символы в программу, используется обратный слеш (называемый символом начала управляющей последовательности), указывающий, что следующий за ним символы является управляющими. Следовательно, чтобы вставить в программу символ табуляции, нужно ввести одиночную кавычку, обратный слеш, букву t и снова одиночную кавычку:
char tabCharacter = '\t';
В этом примере объявляется переменная типа char (с именем tabCharacter), которая тут же инициализируется символьным значением \t, распознаваемым как символ табуляции. Специальные символы форматирования используются при выводе информации на экран, в файл или на другое устройство вывода (например, принтер).
Символ начала управляющей последовательности изменяет значение символа, который следует за ним. Например, обычно символ n означает букву я, но когда перед ней стоит символ начала управляющей последовательности (\), то он превращается в символ разрыва строки.
Таблица 3.2. Управляющие символы.
Константы
Подобно переменным, константы представляют собой ячейки памяти, предназначенные для хранения данных. Но, в отличие от переменных, константы не изменяются (о чем говорит само название - константа). Создаваемую константу нужно инициализировать, поскольку позже ей нельзя присвоить новое значение,
В языке C++ предусмотрено два типа констант: литеральные и символьные.
Литеральные константы
Литеральная константа - это значение, непосредственно вводимое в самой программе. Например, в выражении
int myAge = 39;
myAge является переменной типа int, а число 39 - литеральной константой. Нельзя присвоить никакое значение константе 39.
Символьные константы
Символьная константа - это константа, представленная именем (точно так же, как именем представляется любая переменная). Однако, в отличие от переменной, значение инициализированной константы изменить нельзя.
Если в вашей программе есть одна целочисленная переменная с именем students, а другая - с именем classes, вы могли бы вычислить общее количество учеников школы при условии, что вам известно, сколько классов в школе и сколько учеников в каждом классе (допустим, каждый класс состоит из 15 учеников):
students = classes * 15;
Примечание:Символ (*) означает умножение.
В этом примере число 15 является литеральной константой. Но если эту литеральную константу заменить символьной, то вашу программу будет легче читать и изменять в будущем:
students = classes * studentsPerClass
Если впоследствии потребуется изменить количество учеников в каждом классе, вы сможете сделать это единожды в той строке программы, где определяется константа studentsPerClass, и вам не придется вносить изменения во все строки программы, где используется это значение.
В языке C++ существует два способа объявления символьной константы. Традиционный и ныне уже устаревший способ состоит в использовании директивы препроцессора #define.
Определение констант с помощью директивы #deiine
Для определения константы традиционным способом введите следующее выражение:
#define studentsPerClass 15
Обратите внимание на то, что константа studentsPerClass не имеет никакого конкретного типа (int, char и т.д.). Директива #define выполняет простую текстовую подстановку. Каждый раз, когда препроцессор встречает слово studentsPerClass, он заменяет его литералом 15.
Поскольку препроцессор запускается перед компилятором, последний никогда не увидит константу, а будет видеть только число 15.
Определение констант с помощью ключевого слова const
Хотя директива #define и справляется со своими обязанностями, в языке C++ существует новый, более удобный способ определения констант:
const unsigned short int studentsPerClass = 15;
В этом примере также объявляется символическая константа с именем studentsPerClass, но на сей раз для этой константы задается тип unsigned short int. Этот способ имеет несколько преимуществ, облегчая дальнейшую поддержку вашей программы и предотвращая появление некоторых ошибок. Самое важное отличие этой константы от предыдущей (объявленной с помощью директивы #define) состоит в том, что она имеет тип и компилятор может проследить за ее использованием только по назначению (т.е. в соответствии с объявленным типом).
Примечание:Во время работы программы константы изменять нельзя. Если же возникла необходимость в изменении, например, константы studentsPerClass, вам нужно изменить соответствующее объявление в программе и перекомпилировать ее.
Рекомендуется:Следите, чтобы значения переменных не превышали допустимый предел. Присваивайте переменным осмысленные имена, отражающие их назначение. Используйте типы short и long, чтобы более эффективно управлять памятью компьютера.
Не рекомендуется: Не используйте в качестве имен переменных ключевые слова.
Константы перечислений
Перечисления позволяют создавать новые типы данных, а затем определять переменные этих типов, значения которых ограничены набором константных значений. Например, можно объявить C0L0R как перечисление и определить для него пять значений: RED, BLUE, GREEN, WHITE И BLACK.
Для создания перечисления используется ключевое слово enum, за которым следуют: имя типа, открывающая фигурная скобка, список константных значений, разделенных запятыми, закрывающая фигурная скобка и точка с запятой. Например:
enum COLOR { RED, BLUE, GREEN, WHITE, BLACK };
Это выражение выполняет две задачи.
1. Создается перечисление с именем C0L0R, являющееся новым типом.
2. Определяются символьные константы: RED со значением 0; BLUE со значением 1; GREEN со значением 2 и т.д.
Каждой константе перечисления соответствует определенное целочисленное значение. По умолчанию первая константа инициализируется значением 0, а каждая следующая - значением, на единицу большим предыдущего. Однако любую константу можно инициализировать произвольным значением, и в этом случае явно неинициализированные константы продолжат возрастающую последовательность, взяв за точку отсчета значение, стоящее перед ними. Таким образом, если записать
enum Color { RED=100, BLUE, GREEN=500, WHITE, BLACK=700 };
то константа red будет иметь значение 100; константа blue - 101; константа GREEN - 500; константа WHITE - 501; константа BLACK - 700.
Теперь можно определить переменные типа C0L0R, но каждой из них можно присвоить только одно из перечислимых значений (в данном случае RED, BLUE, GREEN, WHITE или BLACK либо 100, 101, 500, 501 или 700). Переменной C0L0R можно присвоить любое значение цвета. На самом деле этой переменной можно присвоить любое целое значение, даже если оно не соответствует ни одному из разрешенных цветов, но в этом случае приличный компилятор должен возмутиться и показать предупреждающее сообщение. Важно понимать, что переменные перечисления на самом деле имеют тип unsigned int и целочисленным переменным присваиваются заданные константы перечисления. Однако иногда при работе с цветами, днями недели или другими подобными наборами значений неплохо иметь возможность называть эти значения по имени. В листинге 3.7 представлена программа, в которой используется тип перечисления.
Листинг 3.7. Использование перечисления
1: #include <iostream.h>
2: int main()
3: {
4: enum Days { Sunday, Monday, Tuesday,
5: Wednesday, Thursday, Friday, Saturday };
6: int choice;
7: cout << "Enter a day (0-6): ";
8: cin << choice;
9: if (choice = Sunday || choice == Saturday)
10: cout << "\nYou're already off on weekends!\n";
11: else
12: cout << "\nOkay, I'll put in the vacation day.\n";
13: return 0;
14: }
Результат:
Enter a day (0-6): 6
You're already off on weekends!
Анализ: В строке 4 определяется перечисление DAYS с семью константными значениями. Все они образуют возрастающую последовательность чисел, начиная с нуля; таким образом, значение вторника (Tuesday) равно 2.
Пользователю предлагается ввести значение между 0 и 6. Он не может ввести слово Sunday, поскольку в программе не предусмотрен перевод символов в значение перечисления. Но можно проверить введенное пользователем значение, сравнив его с константными значениями перечисления, как показано в строке 9. Использование перечисления облегчает анализ программы. Того же эффекта можно добиться, используя константы целочисленного типа, как показано в листинге 3.8.
Примечание:Для этой и всех небольших программ в данной книге я намеренно не предусматривал включения ряда выражений, которые обычно пишутся для обработки ситуаций, связанных с приемом от пользователя неверных данных. Например, в этой программе отсутствует проверка вводимых чисел, которая должна обязательно присутствовать в настоящей программе и предназначена для предупреждения ввода неразрешенных чисел. Это было сделано намеренно, для того чтобы сэкономить место в книге и сосредоточить ваше внимание только на рассматриваемой в данном разделе теме.
Листинг 3.8. Та же программа, но с использованием констант целочисленного типа
1: #include <iostream.h>
2: int main()
3: {
4: const int Sunday = 0;
5: const int Monday = 1;
6: const int Tuesday = 2;
7: const int Wednesday = 3;
8: const int Thursday = 4;
9: const int Friday = 5;
10: const int Saturday = 6: 11;
12: int choice;
13: cout << "Enter a day (0-6): ";
14: cin << choice;
15:
16: if (choice = Sunday || choice == Saturday)
17: cout << "\nYou're already off on weekends!\n";
18: else
19: cout << "\nOkay, I'll put in the vacation day.\n";
20:
21: return 0;
22: }
Результат:
Enter a day (0-6): 6
You're already off on weekends!
Результаты работы этой программы идентичны результатам программы из листинга 3.7. Но в этом варианте все константы (Sunday, Monday и пр.) определены в явном виде и отсутствует тип перечисления Days. Обратите внимание, что программа с перечислением короче и логичнее.