Министерство финансов Российской Федерации
Всероссийская государственная налоговая академия
ИНФОРМАТИКА И ПРОГРАММИРОВАНИЕ
Бакалавры: 230700 "Прикладная информатика"
Язык программирования С++
Лабораторная работа № 04
ПРОСТЕЙШИЕ КОНСТРУКЦИИ АЛГОРИТМИЧЕСКОГО ЯЗЫКА С++
Автор профессор кафедры "Прикладной информатики в экономике"
кандидат технических наук Л.К. Кузнецов
Марта 2012 г.
Москва
ВГНА
Лабораторная работа № 04
Простейшие конструкции алгоритмического языка С++
Цель работы:
Ø ознакомиться с операциями языка С++;
Ø ознакомиться с приоритетом выполнения операций в языке С++;
Ø ознакомиться с операциями инкремента и декремента;
Ø ознакомиться с преобразованием типов;
Ø ознакомиться с правилами записи выражений;
Ø ознакомиться выражениями:
Ø ознакомиться перечислениями;
Ø ознакомиться с константами;
Ø научиться управлять порядком, в котором C++ выполняет операции;
Ø научитьсяобъявлять переменные в программах на языке С++;
Ø научиться правильно выбирать имена переменных;
Ø научиться составлять таблицу идентификаторов;
Ø научиться присваивать значения переменной;
Ø научиться присваивать значения при объявлении;
Ø изучить список ключевых слов языка С++.
В ходе этой лабораторной работы студенту предлагается выполнить ряд действий, которые должны выработать практические навыки: по программированию алгебраических выражений с использованием математических функций библиотеки языка C++; по выбору имен переменных; по записи констант; по объявлению переменных.
Для успешной защиты лабораторной работы студент должен выполнить задания и ответить на вопросы для самоконтроля, приведенные в данной лабораторной работе.
1. КРАТКИЕ ТЕОРЕТИЧЕСКИЕ СВЕДЕНИЯ
1.1. Операции
Операции осуществляют пересылку и преобразование данных в программах. Обозначаются операции одним или несколькими символами, например +, -, >> и т.д. Данные, участвующие в операции, называются операндами. В качестве операндов могут использоваться переменные, константы, выражения.
Над числовыми данными определены следующие группы операций (рис. 4.1).
В соответствии с количеством операндов, которые используются в операциях они делятся на унарные (один операнд), бинарные (два операнда) и тернарную (три операнда).
Унарные операции (один операнд) выполняются справа налево. Некоторые унарные операции приведены в табл. 4.1.
| Операции над числовыми данными в С++ | |||||||||||||||||||||||||||||||||||
| Арифметические операции | Операция присваивания | Операции отношения | Логические операции | Операция запятая (,) | Операция приведения к типу | ||||||||||||||||||||||||||||||
| Рис. 4.1. Операции над числовыми данными | |||||||||||||||||||||||||||||||||||
Таблица 4.1
Унарные операции
| Знак операции | Операция | Описание |
| - | Унарный минус | |
| ~ | Побитовое логическое отрицание | |
| ! | Логическое отрицание | В качестве логических значений используется 0 (false) - ложь и не 0 (true) - истина, отрицанием 0 будет 1, отрицанием любого ненулевого числа будет 0. |
| + | Унарный плюс | |
| ++ | Увеличение (инкремент) на единицу | префиксная операция - увеличивает операнд до его использования, постфиксная операция увеличивает операнд после его использования. |
| -- | Уменьшение (декремент) единицу | префиксная операция - уменьшает операнд до его использования, постфиксная операция уменьшает операнд после его использования. |
| sizeof | вычисление размера (в байтах) для объекта того типа, который имеет операнд | |
| & | Получение адреса операнда | |
| * | Получение значения, находящегося по указанному адресу (разыменование) | |
| new | Выделение памяти | Динамическое распределение памяти. |
| delete | Освобождение памяти | Динамическое распределение памяти. |
| (type) | Преобразование типа |
В отличие от унарных, бинарные операции (два операнда), список которых приведен в табл. 4.2, выполняются слева направо.
Таблица 4.2
Бинарные операции
| Знак операции | Операция | Группа операций | Описание |
| * | Умножение | Арифметические мультипликативные | умножение операндов арифметического типа |
| / | Деление | деление операндов арифметического типа (если операнды целочисленные, то выполняется целочисленное деление) | |
| % | Остаток от деления | получение остатка от деления целочисленных операндов | |
| + | Сложение | Арифметические аддитивные | бинарный плюс (сложение арифметических операндов) |
| - | Вычитание | бинарный минус (вычитание арифметических операндов) | |
| << | Сдвиг влево | Операции сдвига | |
| >> | Сдвиг вправо | ||
| < | Меньше | Операции отношения | меньше, чем |
| > | больше | больше | |
| <= | Меньше или равно | меньше или равно | |
| >= | Больше или равно | больше или равно | |
| = = | Равно | Равно??? | |
| != | Не равно | не равно | |
| & | Битовая операция И | Битовые (поразрядные) операции | |
| | | Поразрядное ИЛИ | ||
| ^ | Поразрядное исключающее ИЛИ | ||
| && | Логическое И | Логические операции | конъюнкция (И) целочисленных операндов или отношений, целочисленный результат ложь(0) или истина( не 0) |
| || | Логическое ИЛИ | дизъюнкция (ИЛИ) целочисленных операндов или отношений, целочисленный результат ложь(0) или истина(не 0) | |
| , | Последовательное вычисление | Последовательного вычисления | |
| = | Присваивание | Операции присваивания | присваивание |
| *= | Умножение с присваиванием | умножение с присваиванием (мультипликативное присваивание) | |
| /= | Деление с присваиванием | деление с присваиванием | |
| %= | Остаток от деления с присваиванием | деление с остатком с присваиванием | |
| -= | Вычитание с присваиванием | вычитание с присваиванием | |
| += | Сложение с присваиванием | сложение с присваиванием | |
| <<= | Сдвиг влево с присваиванием | ||
| >>= | Сдвиг вправо присваиванием | ||
| &= | Поразрядное И с присваиванием | ||
| |= | Поразрядное ИЛИ с присваиванием | ||
| ^= | Поразрядное исключающее ИЛИ с присваиванием |
Тернарной операцией (три операнда) является операция «условие ?», которая реализует алгоритмическую структуру ветвления (не рассматривается в рамках лабораторного практикума).
Таблица 4.3
Тернарная операция
| Знак операции | Операция | Описание |
| ?: | Условная операция; в ней используется три операнда. | Выражение1 ? Выражение2 : Выражение3; Первым вычисляется значение выражения1. Если оно истинно, то вычисляется значение выражения2, которое становится результатом. Если при вычислении выражения1 получится 0, то в качестве результата берется значение выражения3. Например: x<0 ? -x : x ; //вычисляется абсолютное значение x. |
1.2. Порядок (старшинство) выполнения операций
Полный список операций (операторов), упорядоченный по приоритетам, приведен в табл. 4.4. Таблица разделена на сегменты двойными линиями. Операторы в каждом сегменте имеют одинаковый приоритет, причем более высокий, чем у операторов в последующих сегментах. Например, префиксный оператор инкремента и оператор обращения к значению расположены в одном сегменте. Следовательно, они имеют одинаковый приоритет, превосходящий приоритет арифметических операторов и операторов сравнения. Более подробно некоторые из этих операторов рассматриваются в последующих лабораторных работах.
В языке Си++ определено 19 категорий приоритетов операций. В табл. 4.4 категории приоритетов названы рангами. Операции ранга 1 имеют наивысший приоритет. Операции одного ранга имеют одинаковый приоритет, и если их в выражениях несколько, то они выполняются в соответствии с правилом ассоциативности либо слева направо (Л®), либо справа налево (П). Если один и тот же знак операции приведен в таблице дважды, то первое появление (с меньшим но номеру, т.е. старшим по приоритету, рангом) соответствует унарной операции, а второе – бинарной. Отметим, что кроме стандартных режимов использования операций язык С++ допускает расширение их действий на объекты классов, вводимых пользователем или уже определенных в конкретной реализации языка. Примером такого расширения (перегрузки) является операция извлечения данных из потока << и операция передачи данных в выходной поток >>, применяемые к потокам ввода cin и вывода cout.
Таблица 4.4
Приоритеты операций
| Ранг | Порядок | Операция (оператор) | Действие | Применение |
| Л | : : | Глобальная область видимости | : : имя | |
| Л | : : | Область видимости класса | класс::имя | |
| Л | : : | Область видимости пространства имен | пространствоимен::имя | |
| Л | . | Обращение к члену класса | объект.член | |
| Л | - > | Обращение к члену класса | указатель->член | |
| Л | [] | Индексирование | переменная [выражение] | |
| Л | () | Вызов функции | имя(список_выражений) | |
| Л | () | Создание типа | тип(список_выражений) | |
| П | ++ | Постфиксный инкремент | 1 -значение++ | |
| П | -- | Постфиксный декремент | 1-значение-- | |
| П | typeid | Идентификатор типа | typeid(тип) | |
| П | typeid | Идентификатор типа времени выполнения | typeid(выражение) | |
| П | Явное приведение | Преобразование типов | имя_приведения<тип>(выражение) | |
| П | sizeof | Размер объекта | sizeofвыражение | |
| П | sizeof | Размер типа | sizeof(тип) | |
| П | ++ | Префиксный инкремент | ++1-значение | |
| П | -- | Префиксный декремент | - -1 -значение | |
| П | ~ | Побитовый NOT | ~выражение | |
| П | ! | Логический NOT | !выражение | |
| П | - | Унарный минус | -выражение | |
| П | + | Унарный плюс | +выражение | |
| П | * | Обращение к значению | *выражение | |
| П | & | Обращение к адресу | &выражение | |
| П | () | Преобразование типов | (тип) выражение | |
| П | new | Создание объекта | newтип | |
| П | delete | Освобождение объекта | deleteвыражение | |
| П | delete [] | Освобождение массива | delete []выражение | |
| Л | ->* | Указатель на член класса | указатель ->* указатель_на_ член | |
| Л | . * | Указатель на член класса | объект .* указатель_на_ член | |
| Л | * | Умножение | выражение * выражение | |
| Л | / | Деление | выражение / выражение | |
| Л | % | Деление по модулю (остаток) | выражение % выражение | |
| Л | + | Сумма | выражение + выражение | |
| Л | - | Разница | выражение - выражение | |
| Л | << | Побитовый сдвиг влево | выражение << выражение | |
| Л | >> | Побитовый сдвиг вправо | выражение >> выражение | |
| Л | < | Меньше | выражение < выражение | |
| Л | < = | Меньше или равно | выражение <= выражение | |
| Л | > | Больше | выражение > выражение | |
| Л | > = | Больше или равно | выражение >= выражение | |
| Л | == | Равенство | выражение == выражение | |
| Л | != | Неравенство | выражение != выражение | |
| Л | & | Побитовый AND | выражение & выражение | |
| Л | ^ | Побитовый XOR | выражение ^ выражение | |
| Л | | | Побитовый OR | выражение | выражение | |
| Л | && | Логический AND (конъюнкция «И») | выражение && выражение | |
| Л | || | Логический OR (дизъюнкция «ИЛИ») | выражение || выражение | |
| П | ?: | Условная операция | выражение ? выражение : выражение | |
| П | = | Присвоение | 1-значение = выражение | |
| П | *=, /=, %=, | Составные операторы присвоения | 1-значение += выражение и т.д. | |
| П | +=, -= | |||
| П | <<=, >>= | |||
| П | &=, |=, ^= | |||
| П | throw | Передача исключения | throwвыражение | |
| Л | , | Запятая | выражение , выражение |
Порядок определяет последовательность группировки операций (операторов) при одинаковом уровне приоритета. Вопросы порядка весьма существенны и в некоторых других случаях. Например, правосторонний порядок (П) оператора присвоения позволяет создавать составные операторы присвоения.
ival - jval = kval = lval // правосторонний порядок
(ival = (jval = (kval = lval))) // эквивалентная версия со скобками
Это выражение сначала присваивает значение переменной lval переменной kval, полученный результат присваивается переменной jval и, наконец, переменной ival.
Арифметические операторы, напротив, имеют левосторонний порядок (Л).
ival * jval / kval * lval // левосторонний порядок
(((ival * jval) / kval) * lval) // эквивалентная версия со скобками
В этом выражении, например, происходит умножение значений переменных ival и jval, затем деление результата на значение переменной kval и, наконец, умножение результата деления на lval.
Замечание:поскольку в лабораторных работах с 1-й по 5-ю используются исключительно арифметические операции, то при написании программ на С++ удобнее пользоваться на первых порах более простой и компактной табл. 3.4 (лабораторная работа № 3), в которой приведен приоритет (ранг) только арифметических операций. Начиная с лабораторной работы 6 при написании программ на языке С++ будут использоваться по мимо арифметических операций и другие операции языка С++, в этом случае необходимо обращаться к табл. 4.4.
В заключение рассмотрения работы с арифметическими операциями отметим, что приоритет операций умножения и деления выше приоритета операций сложения и вычитания. Это означает, что сначала выполняются операции умножения и деления и только затем операции сложения и вычитания. Пример 4.1 демонстрирует приоритет арифметических операций:
Пример 4.1.
double n=2, SCALE = 1.2;
double arg = 25.0 + 60.0*n/SCALE;
В приведенном примере сначала будет выполнена операция умножения, затем деления и, наконец, сложения. То есть порядок вычисления соответствует математическим правилам. Для того чтобы изменить порядок вычисления (поменять приоритеты) используются круглые скобки как показано ниже
Результат выражения зависит от группировки составляющих его операторов. Например, при вычислении выражения в примере 4.2 слева направо получится 20.
Пример 4.2.
6+3*4/2+2;
Для выражения примера 4.2 вполне возможны и другие результаты: 9, 14 и 36.Напомним, что в языке С++ результат вычисления выражения составит 14.
Умножение и деление имеют более высокий приоритет, чем сложение. Их операнды связаны с операторами жестче, чем операнды операторов сложения. Умножение и деление имеют одинаковый приоритет. Операторы имеют также порядок выполнения, который определяет последовательность группировки операндов у операторов с одинаковым уровнем приоритета. Арифметические операторы имеют левосторонний порядок, т.е. они группируются слева направо. Теперь вполне очевидно, что приведенное выше выражение можно переписать следующим образом.
int temp = 3*4 //12
int temp2 = temp /2 //6
int temp3 = temp2 + 6 //12
int result = temp3 + 2 // 14
1.3. Управление порядком, в котором C++ выполняет операции
Круглые скобки позволяют переопределить приоритет операций!
Как вы уже знаете, C++ назначает операциям различный приоритет, который и управляет порядком выполнения операций. К сожалению, иногда порядок, в котором C++ выполняет арифметические операции, не соответствует порядку, в котором вам необходимо их выполнить. Например, предположим, что вашей программе необходимо сложить две стоимости и затем умножить результат на налоговую ставку:
Пример 4.3.
cost = price_a + price_b * 1.06;
К сожалению, в этом случае C++ сначала выполнит умножение (price_b * 1.06), а затем прибавит значение price_a.
Для переопределения приоритета можно использовать круглые скобки. Выражения в круглых скобках обрабатываются как отдельные модули. Когда C++ оценивает выражение, он сначала всегда выполняет операции, сгруппированные в круглых скобках, а во всех остальных случаях применяется обычные правила приоритета.
Пример 4.4.
Рассмотрим следующее выражение:
result =(2+3)* (3+4);
C++ вычисляет данное выражение в следующем порядке:
result = (2 + 3) * (3 + 4);
= (5) * (3 + 4);
= 5 * (7);
=5*7;
= 35;
Пример 4.5.
Используя круглые скобки в выражении примера 4.2, можно принудительно получить любой из четырех возможных вариантов.
// круглые скобки позволяют изменить стандартный приоритет
// и порядок выполнения операторов
cout << ((6 + ((3 * 4) / 2)) + 2) << endl; //результат 14
// круглые скобки позволяют создать альтернативные группировки
cout << (6+3) * (4/2+2) << endl; //результат 36
cout << ((6+3) * 4) /2+2 << endl; //результат 20
cout << 6+3*4/ (2+2) << endl; // результат 9
В качестве примера рассмотрим следующее выражение:
*iter++;
Приоритет оператора ++ выше приоритета оператора *. Это значит, что сначала выполняется часть iter++,a ee результат становится операндом оператора *. Таким образом, обращение к значению итератора iter происходит после его инкремента. Но если бы необходимо было увеличить значение, на которое указывает итератор iter, пришлось бы применить круглые скобки, чтобы явно указать свои намерения.
(*iter)++; // увеличить значение, на которое указывает
// итератор iter
Круглые скобки указывают, что операнд * применяется к итератору iter. Теперь как операнд оператора ++ в выражении используется часть *iter.
Группируя выражения внутри круглых скобок, вы можете управлять порядком, в котором C++ выполняет арифметические операции.
Пример 4.6.
Для задания правильного алгоритма вычислений в примере 4.6, необходимо сложить две стоимости внутри круглых скобок, как показано ниже:
cost = (price_a + price_b) * 1.06;
Рекомендация: в сомнительных случаях сами доопределяйте приоритет операций с помощью круглых скобок.
Пример 4.7:
2 + 2 * 2 = 6; (2 + 2) * 2 = 8.
1.4. Разделители
Разделители, или знаки пунктуации, входят в число лексем языка:
[] () {} , ; : ... * = # &
Квадратные скобки '[ ]' ограничивают индексы одно- и многомерных массивов и индексированных элементов.
Круглые скобки '()':
1) выделяют условные выражения (в операторе if «если»);
2) входят как обязательные элементы в определение и описание (в прототип) любой функции, где выделяют соответственно список формальных параметров и список спецификаций параметров;
3) обязательны в определении указателя на функцию;
4) группируют выражения, изменяя естественную последовательность выполнения операций;
5) входят как обязательные элементы в операторы циклов;
6) необходимы при явном преобразовании типа;
7) применение круглых скобок настоятельно рекомендуется в макроопределениях, обрабатываемых препроцессором.
Фигурные скобки'{)':
1) обозначают соответственно начало и конец составного оператора или блока;
2) используются для выделения списка компонентов в определениях типов структур, объединений, классов;
3) используются при инициализации массивов и структур при их определении;
Запятая '(,)' разделяет элементы списков:
1) списки начальных значений, присваиваемых индексированным элементам массивов и компонентам структур при их инициализации;
2) списки формальных и фактических параметров и их спецификаций в функциях;
3) в заголовке оператора цикла for;
4) в описаниях и определениях объектов (переменных) одного типа;
5) при описании производного класса
Замечание: не путайте использование запятой-операции с запятой-разделителем.
Точка с запятой ';' завершает каждый оператор, каждое определение (кроме определения функции) и каждое описание. Любое допустимое выражение, за которым следует ; воспринимается как оператор. Это справедливо и для пустого выражения, т.е. отдельный символ "точка с запятой" считается пустым оператором.
Двоеточие ':' служит:
1) для отделения (соединения) метки и помечаемого ею оператора;
2) описание производного класса, где имя класса отделяется от списка базовых классов двоеточием.
Многоточие '…' – это три точки без пробелов между ними. Оно используется для обозначения переменного числа параметров у функции при ее определении и описании (при задании ее прототипа).
Звездочка '*'. В описаниях и определениях звездочка означает, что описывается указатель на значение использованного в объявлении типа.
Замечание: не путайте использование звездочки-разделителя с использованием звездочки в качестве знака операции умножения и знака операции разыменования (получения значения через указатель).
Знак '=':
1) в определении он отделяет описание объекта от списка его инициализации;
2) в списке формальных параметров функции знак = указывает на выбираемое по умолчанию значение аргумента (фактического параметра).
Замечание: не путайте использование знака = -разделителя с использованием знака = в качестве знака операции присваивания.
Символ '#' (знак номера или диеза в музыке) используется для обозначения директив (команд) препроцессора. Если этот символ является первым отличным от пробела символом в строке программы, то строка воспринимается как директива препроцессора.
Символ '&' играет роль разделителя при определении переменных типа ссылки.
Замечание: подробное рассмотрение символов-разделителей отложим до последующих работ. Символы-разделители будут подробно изучаться по мере их использования в конкретных ситуациях.
1.5. Переменные
Для того, чтобы программа могла на протяжении своего выполнения сохранять определенные данные, используются переменные и константы.
Переменная - объект программы, занимающий в общем случае несколько ячеек памяти, призванный хранить данные. Переменная обладает именем, размером и рядом других атрибутов (таких, как видимость, время существования и т.д.).
Переменная в C++ – именованная область памяти, в которой хранятся данные определенного типа. У переменной есть имя и значение. Имя служит для обращения к области памяти, в которой хранится значение.
1.5.1. Объявление переменных
Чтобы переменную можно было использовать в программе, она должна быть предварительно объявлена.
Перед использованием любая переменная должна быть описана (объявлена), например:
int a; float x;
При объявлении переменной для нее резервируется некоторая область памяти, размер которой зависит от конкретного типа переменной. Здесь следует также указать, что размер одного и того же типа данных может отличаться на компьютерах разных платформ, а также может зависеть от используемой операционной системы. Поэтому при объявлении той или иной переменной нужно четко представлять, сколько байт она будет занимать в памяти ЭВМ, чтобы избежать проблем, связанных с переполнением и неправильной интерпретацией данных.
Ваши программы используют переменные для хранения информации. В зависимости от типа хранимого значения, например, целое число, буква алфавита или число с плавающей точкой, тип вашей переменной будет разным.
Тип переменной указывает тип значения, хранимого в переменной, а также набор операций (таких как сложение, умножение и другие), которые программа может выполнять над значением переменной. Большинство программ на C++ будут использовать типы переменных, перечисленные в табл. 4.5.
Ниже приведен перечень базовых типов переменных и их размер в байтах. Следует учесть, что размер, указанный в табл. 4.5 для каждого типа, должен быть проверен для конкретного ПК.
Таблица 4.5
Базовые типы типы переменных C++
| Тип | Размер, байт | Хранимые значения |
| bool | true или false | |
| unsigned short int | от 0 до 65 535 | |
| short int | От -32 768 до 32 767 | |
| unsigned long int | от 0 до 4 294 967 295 | |
| long int | От -2 147 483 648 до 2 147 483 647 | |
| int (16 разрядов) | От -32 768 до 32 767 | |
| int (32 разряда) | От -2 147 483 648 до 2 147 483 647 | |
| unsigned int (16 разрядов) | от 0 до 65 535 | |
| unsigned int (32 разряда) | от 0 до 4 294 967 295 | |
| char | от 0 до 256 | |
| float | от 1.2е-38 до 3.4е38 | |
| double | От 2.2е-308 до 1.8е308 | |
| void | 2 или 4 |
Прежде чем вы сможете использовать переменную, ваша программа должна ее объявить. Другими словами, вам следует представить переменную компилятору C++. Чтобы объявить переменную в программе, вам следует указать тип переменной и ее имя, по которому программа будет обращаться к данной переменной. Указывайте тип и имя переменной после открывающей фигурной скобки главной программы, как показано ниже:
тип_переменной имя_переменной;
Объявление переменной начинается с ключевого слова, определяющего его тип, за которым следует собственно имя переменной и (необязательно) инициализация - присвоение начального значения.
Одно ключевое слово позволяет объявить несколько переменных. При этом они следуют друг за другом через запятую (,). Заканчивается объявление символом точка с запятой (;).
Имя переменной (идентификатор) не должно превышать 256 символов (разные компиляторы накладывают свои ограничения на количество распознаваемых символов в идентификаторе). При этом важно учитывать регистр букв (Abc и аbс - не одно и то же)! Конечно, имя должно быть достаточно информативным, однако не следует использовать слишком длинные имена, так как это приводит к опискам.
Хотя начальная инициализация и не является обязательной при объявлении переменной, все же рекомендуется инициализировать переменные начальным значением. Если этого не сделать, переменная изначально может принять непредсказуемое значение.
Установка начального значения переменной осуществляется с помощью оператора присваивания (=).
Как правило, тип переменной будет одним из типов, перечисленных в табл. 4.5. Выбираемое вами имя переменной должно нести смысловую нагрузку, которая описывает (для всех, кто читает вашу программу) использование переменной. Например, ваша программа могла бы использовать переменные, такие как employee_name, employee_age и т. д. Обратите внимание на точку с запятой, которая следует за именем переменной. В C++ объявление переменной считается оператором. Поэтому вы должны поставить после объявления точку с запятой.
Пример 4.8
Фрагмент следующей программы объявляет три переменные, используя типы int, float и long:
#include <iostream.h>
void main(void)
{
int test_score;
float salary;
long distance_to_mars;
}
Важно обратить внимание, что данная программа ничего не выполняет, а только объявляет переменные. Как видите, объявление каждой переменной заканчивается точкой с запятой. Если вы объявляете несколько переменных одного и того же типа, можно разделять их имена запятой. Следующий оператор, например, объявляет три переменных с плавающей точкой:
float salary, income_tax, retirement_fund;
Помните:переменная представляет собой имя ячейки в памяти компьютера. Во время выполнения ваши программы хранят информацию в переменных. При создании программ вы должны объявлять переменные, сообщая компилятору C++ имя и тип переменной.
Рассмотрим подробно основные типы переменных.
Переменная типа bool занимает всего 1 байт и используется, прежде всего, в логических операциях, так как может принимать значение 0 (false, ложь) или отличное от нуля (true, истина). В старых текстах программ вы можете встретить тип данных BOOL и переменные этого типа, принимающие значения TRUE и FALSE. Этот тип данных и указанные значения не являлись частью языка, а объявлялись в заголовочных файлах как unsigned short, 1 и 0, соответственно. В новой редакции С++ bool -самостоятельный, полноправный тип.
Часто бывает необходимо указать в программе, что переменная должна принимать только целые значения. Целочисленные переменные (типа int, long, short), как следует из названия, призваны хранить целые значения, и могут быть знаковыми и беззнаковыми. Знаковые переменные могут представлять как положительные, так и отрицательные числа. Для этого в их представлении один бит (самый старший) отводится под знак. В отличие от них, беззнаковые переменные принимают только положительные значения. Чтобы указать, что переменная будет беззнаковой, используется ключевое слово unsigned. По умолчанию целочисленные переменные считаются знаковыми (signed, чаще всего опускается; используется при преобразовании типов данных).
Из таблицы 4.5 видно, что переменная типа int в разных случаях может занимать в памяти различное число байт.
Символьный тип данных char применяется, когда переменная должна нести информацию о коде ASCII. Этот тип данных часто используется для построения более сложных конструкций, таких, как строки, символьные массивы и т.д. Данные типа char также могут быть знаковыми и беззнаковыми.
Для представления чисел с плавающей запятой применяют тип данных float. Этот тип, как правило, используется для хранения не очень больших дробных чисел и занимает в памяти 4 байта: 1 бит - знак, 8 бит - экспонента, 23 бита - мантисса.
Если вещественное число может принимать очень большие значения, используют переменные двойной точности, тип double.
Переменная типа void не имеет значения и служит для согласования синтаксиса. Например, синтаксис требует, чтобы функция возвращала значение. Если не требуется использовать возвращенное значение, перед именем функции ставится тип void.
Приведем несколько примеров объявления переменных.
Пример 4.9
int а = 0, А = 1;
float aGe = 17.5;
double PointX;
bool bTheLightlsOn = false;
char LETTER = 'Z';
void MyFunction(); // возвращаемое функцией
// Значение игнорируется
1.5.2. Смысловые имена переменных
Каждая создаваемая вами переменная должна иметь уникальное имя. Чтобы сделать свои программы более легкими для чтения и понимания, следует использовать смысловые имена переменных. Например, следующий оператор объявляет три переменных с именами х, y и z:
int х, у, z;
Предположим, что эти переменные хранят возраст, тестовые очки и оценку студента, тогда следующие имена переменных более понятны по смыслу для других программистов, читающих ваш исходный код:
int student_age, test_score, grade;
При выборе имен переменных можно использовать комбинацию букв, цифр и подчеркивания (_). Первый символ в имени переменной должен быть буквой или подчеркиванием. Нельзя начинать имя переменной с цифры. Кроме того, в C++ буквы нижнего и верхнего регистров считаются разными. Сначала для имен своих переменных используйте только буквы нижнего регистра. Как только вы освоитесь в C++, можете комбинировать буквы верхнего и нижнего регистров для получения смысловых имен, как показано ниже:
float MonthlySalary, IncomeTax;
1.5.3. Таблица идентификаторов
Одним из базовых свойств программы является идентификатор.
Под идентификатором понимается имя переменной, имя функции или метка. В программе идентификатор может содержать прописные и строчные латинские буквы, цифры и символ подчеркивания и обязательно начинается с буквы или символа подчеркивания и не должен совпадать с ключевым словом с учетом регистра. Так. в приведенном выше примере представлены идентификаторы а, b, с и d.
Чтобы переменную можно было использовать в программе, она должна быть предварительно объявлена. Создание идентификаторов как раз и осуществляется при таком объявлении.
Важным этапом при написании программ на алгоритмическом языке С++ является этап составления таблицы идентификаторов (таблицы кодирования переменных). Необходимость составления такой таблицы объясняется тем, что, как правило, в исходных математических выражениях для вычислений используются символы, не разрешенные к использованию в языке С++. Например, буквы греческого и русского алфавита. Либо используются надстрочные и подстрочные индексы, что также не разрешено в С+