Определение констант с помощью директивы #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. Обратите внимание, что программа с перечислением короче и логичнее.

Резюме

На этом занятии рассматривались числовые и символьные переменные и константы, которые в C++ используются для хранения данных во время выполнения программы. Числовые переменные могуг быть либо целыми (char, short и long int), либо вещественными (float и double). Кроме того, они могут быть знаковыми и беззнаковыми (unsigned). Хотя на различных компьютерах все эти типы могуг иметь разные размеры, но на одном компьютере переменные одного и того же типа всегда имеют постоянный размер.

Переменную нужно объявить до ее использования. При работе с данными необходимо следить, чтобы тип данных соответствовал объявленному типу переменной. Если, например, поместить слишком большое число в целую переменную, возникнет переполнение, которое приведет к неверному результату.

Кроме того, вы познакомились с литеральными, символьными и перечислимыми константами, а также с двумя способами объявления символьных констант: с помощью директивы #define и ключевого слова const.

Вопросы и ответы

Если переменные типа short int могут преподнести сюрприз в виде переполнения памяти, то почему бы не использовать во всех случаях переменные типа long int?

Как короткие (short), так и длинные (long) целочисленные переменные могут переполняться, но для того чтобы это произошло с типом long int, нужно уж слишком большое число. Например, переменная типа unsigned short int переполнится после

числа 65 535, в то время как переменная типа unsigned long int — только после числа 4 294 967 295. Однако на многих компьютерах каждое объявление длинного целого значения занимает вдвое больше памяти по сравнению с объявлением короткого целого (четыре байта против двух), и программа, в которой объявлено 100 таких переменных займет лишних 200 байт ОЗУ. Честно говоря, память сейчас перестала быть проблемой, поскольку большинство персональных компьютеров оснащено многими тысячами (если не миллионами) байтов памяти.

Что случится, если присвоить число с десятичной точкой целочисленной переменной, а не переменной типа float, как в следующей программной строке?

int aNumber = 5.4;

Хороший компилятор выдаст по этому поводу предупреждение, но такое присваивание совершенно правомочно. Присваиваемое число будет в таком случае усечено до целого. Следовательно, если присвоить число 5,4 целочисленной переменной, эта переменная получит значение 5. Однако налицо потеря информации, и если затем хранящееся в этой целой переменной значение вы попытаетесь присвоить переменной типа float, то вещественной переменной придется "довольствоваться" лишь значением 5.

Почему вместо литеральных констант лучше использовать символьные?

Если некоторое значение используется во многих местах программы, то применение символьной константы позволяет изменять все значения путем изменения одного, лишь определения этой константы. Кроме того, смысл символьной константы проще понять по ее названию. Ведь иногда трудно разобраться, почему некоторое значение умножается на число 360, а если это число будет заменено символьной константой degreesInACircle (градусов в окружности), то сразу становится ясно, о чем идет речь.

Что произойдет, если присвоить отрицательное число беззнаковой переменной?

Рассмотрите следующую строку программы:

unsigned int aPositiveNumber = -1;

Хороший компилятор отреагирует на это предупреждением, но такое присвоение вполне законно. Отрицательное число будет представлено в беззнаковом побитовом виде. Так, побитовое представление числа -1 выглядит как 11111111 11111111 (0xFFFF в шестнадцатеричном формате) и соответствует числу 65 535. Если вам что-то непонятно, обратитесь к приложению В.

Можно ли работать с языком C++, не имея представления о побитовом выражении числовых значений и арифметике двоичных и шестнадцатеричных чисел?

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

Коллоквиум

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

Контрольные вопросы

1. В чем разница между целочисленной и вещественной (с плавающей точкой) переменными?

2. Каково различие между типами unsigned short int и long int?

3. Каковы преимущества использования символьной константы вместо литерала?

4. Каковы преимущества использования ключевого слова const вместо директивы

#define?

5. Как влияет на работу программы "хорошее" или "плохое" имя переменной?

6. Если перечисление (enum) заданно таким образом, то каково значение его члена Blue?

enum COLOR { WHITE, BLACK = 100, RED, BLUE, GREEN = 300 };

7. Какие из следующих имен переменных можно считать хорошими, плохими или вообще недопустимыми?

а) Age

б) ! ex