Из урока 4 вы узнали, как объявлять и использовать переменные в своих программах. По мере усложнения программ вы будете выполнять арифметические операции, такие как сложение, вычитание, умножение и деление, над значениями, содержащимися в переменных. Данный урок описывает, как использовать арифметические операторы C++ для выполнения этих операций. К тому времени, когда вы закончите изучение данного урока, вы освоите следующие основные концепции: Для выполнения математических операций используйте в своих программах арифметические операторы C++. Чтобы гарантировать последовательность операций, C++ назначает приоритет каждому оператору. Используя круглые скобки в арифметических выражениях, вы можете управлять порядком, в котором C++ выполняет операции. Многие программы на C++ прибавляют или вычитают единицу, используя операции увеличения (++) или уменьшения (--).
После того как вы научитесь распознавать разные арифметические операторы C++, вы поймете, что выполнять математические операции очень легко! ОСНОВНЫЕ МАТЕМАТИЧЕСКИЕ ОПЕРАЦИИ
Независимо от назначения большинство ваших программ на C++ будут складывать, вычитать, умножать или делить. Вы узнаете, что ваши программы могут выполнять арифметические операции с константами (например, 3*5) или с переменными (например, payment — total). Таблица 5.1 перечисляет основные математические операции C++:
Таблица 5. 1. Основные математические операции С++ Операция Назначение Пример
+ Сложение total = cost + tax;
- Вычитание change = payment - total;
*. Умножение tax = cost * tax_rate;
/ Деление average = total / count;
Следующая программа SHOWMATH.CPP использует cout для вывода реультата нескольких простых арифметических операций:
Посмотрите внимательно на операторы программы. Обратите внимание, что каждое выражение сначала появляется в кавычках, которые обеспечивают вывод символов (например, 5 + 7 =) на экран. Затем программа выводит результат операции и символ новой строки. Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
С:\> SHOWMATH <ENTER>
5 + 7 = 12
12 - 7 = 5
1.2345 * 2 = 2.469
15 / 3 = 5
В данном случае программа выполняла арифметические операции, используя только постоянные значения. Следующая программа MATHVARS.CPP выполняет арифметические операции, используя переменные:
#include <iostream.h>
void main(void)
{ float cost =15.50; // Стоимость покупки float sales_tax = 0.06; // Налог на продажу 6% float amount_paid = 20.00; // Деньги покупателя float tax, change, total; // Налог на продажу, сдача покупателю и общий счет tax = cost * sales_tax; total = cost + tax; change = amount_paid - total; cout << "Стоимость покупки: $" << cost << "\tHaлor: $" << tax << "\tОбщий счет: $" << total << endl; cout << "Сдача покупателю: $" << change << endl; }
В данном случае программа использует только переменные с плавающей точкой. Как видите, программа присваивает значения переменным при объявлении. Далее программа выполняет арифметические операции над переменными для определения налога на продажу, общего счета и сдачи покупателю. Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
С:\> MATHVARS <ENTER>
Стоимость покупки: $15.5 Налог: $0.93 Общий счет: $16.43
Сдача покупателю: $3.57 УВЕЛИЧЕНИЕ ЗНАЧЕНИЯ ПЕРЕМЕННОЙ НА 1
Обычной операцией, которую вы будете выполнять при программировании, является прибавление 1 к значению целой переменной. Например, предположим, что ваша программа использует переменную с именем count, чтобы сохранить данные о количестве напечатанных файлов. Каждый раз, когда программа печатает файл, 1 будет добавляться к текущему значению count. Используя оператор присваивания C++, ваша программа может увеличивать значение count, как показано ниже:
count = count + 1;
В данном случае программа сначала выбирает значение count, а затем добавляет к нему единицу. Далее программа записывает результат сложения обратно в переменную count. Следующая программа INTCOUNT.CPP использует оператор присваивания для увеличения переменной count (которая первоначально содержит значение 1000) на единицу (присваивая переменной результат 1001):
Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
С:\> INCCOUNT <ENTER>
начальное значение count равно 1000
конечное значение count равно 1001
Так как увеличение значения переменной представляет собой обычную операцию в программах, в C++ есть операция увеличения — двойной знак плюс (++). Операция увеличения обеспечивает быстрый способ прибавления единицы к значению переменной. Следующие операторы, например, увеличивают значение переменной count на 1:
count = count + 1; count++;
Следующая программа INC_OP.CPP использует операцию увеличения для наращивания значения переменной count на 1:
#include <iostream.h>
void main(void)
{ int count = 1000; cout << "начальное значение count равно " << count << endl; count++; cout << "конечное значение count равно " << count << endl; }
Эта программа работает так же, как INCCOUNT.CPP, которая использовала оператор присваивания для увеличения значения переменной. Когда C++ встречает операцию увеличения, он сначала выбирает значение переменной, добавляет к этому значению единицу, а затем записывает результат обратно в переменную. Представление о префиксной (до) и постфиксной (после) операциях увеличения
При использовании операций увеличения ваши программы могут размещать оператор увеличения до или после переменной, как показано ниже:
++variable; variable++;
Так как первый оператор появляется до переменной, он называется префиксным оператором увеличения. Аналогично этому, второй оператор появляется после переменной и называется постфиксным оператором увеличения. Вам необходимо знать, что C++ трактует эти два оператора по-разному. Например, рассмотрим следующий оператор присваивания:
current_count = count++;
Этот оператор присваивания указывает C++ присвоить текущее значение count переменной current_count. В дополнение к этому постфиксный оператор увеличения заставляет C++ увеличить текущее значение count. Использование постфиксного оператора в этом случае делает показанный выше оператор эквивалентным следующим двум операторам:
current_count = count;
count = count + 1;
Теперь рассмотрим следующий оператор присваивания, который использует префиксный оператор увеличения:
current_count = ++count;
В этом случае оператор присваивания указывает C++ сначала увеличить значение count, а затем присвоить результат переменной current_count. Использование префиксного оператора увеличения делает показанный выше оператор эквивалентным следующим двум операторам:
count = count + 1;
current_count = count;
Важно освоить префиксную и постфиксную операции увеличения, так, как они будут встречаться вам в большинстве программ на C++. Следующая программа PRE_POST.CPP иллюстрирует использование префиксной и постфиксной операций увеличения:
#include <iostream.h>
void main(void)
{ int small_count = 0; int big_count = 1000; cout << "small_count равно " << small_count << endl; cout << "small_count++ производит " << small_count++ << endl; cout << "конечное значение small_count равно " << sniall_count << endl; cout << "big_count равно " << big_count << endl; cout << "++big_count производит " << ++big_count << endl; cout << "конечное значение big_count равно " << big_count << endl; }
Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
С:\> PRE_POST <ENTER>
small_count равно 0
small_count++ производит 0
конечное значение small_count равно 1
big_count равно 1000
++big_count производит 1001
конечное значение big_count равно 1001
С переменной small_count программа использует постфиксную операцию увеличения. В результате программа выводит текущее значение переменной (0), а затем увеличивает его на 1. С переменной big_count программа использует префиксную операцию увеличения. В результате программа сначала увеличивает значение переменной (1000 + 1), а затем выводит результат (1001). Найдите время, чтобы отредактировать эту программу, и сначала измените постфиксную операцию на префиксную, а затем префиксную на постфиксную. Откомпилируйте и запустите программу, обращая внимание на то, как изменение операции изменяет вывод. С++ обеспечивает также операции уменьшения
Как вы уже знаете, двойной знак плюс (++) представляет собой оператор увеличения C++. Подобным образом двойной знак минус (--) соответствует оператору уменьшения C++, который уменьшает значение переменной на 1. Как и в случае с операцией увеличения, C++ поддерживает префиксный и постфиксный операторы уменьшения. Следующая программа DECCOUNT.CPP иллюстрирует использование оператора уменьшения C++:
#include <iostream.h>
void main(void)
{ int small_count = 0; int big_count = 1000; cout << "small_count равно " << small_count << endl; cout << "small_count-- производит " << small_count-- << endl; cout << "конечное значение small_count равно " " small_count << endl; cout << "big_count равно " << big_count << endl; cout << "--big_count производит " << --big_count << endl; cout << "конечное значение big_count равно " << big_count << endl; }
Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
С:\> DECCOUNT <ENTER”
small_count равно 0
small_count-- производит 0
конечное значение small_count равно -1
big_count равно 1000
—big_count производит 999
конечное значение big_count равно 999
Как видите, префиксный и постфиксный операторы уменьшения C++ работают так же, как и соответствующие операторы увеличения, с той лишь разницей, что они уменьшают значение переменной на 1.
ДРУГИЕ ОПЕРАТОРЫ С++
В этом уроке описаны обычные арифметические операции C++, а также операции увеличения и уменьшения. В программах на C++ вы можете встретить одну или несколько операций, перечисленных в табл. 5.2:
Таблица 5.2. Операции C++, которые вы можете встретить в программах. Операция Функция
% Взятие по модулю или остаток; возвращает остаток целочисленного деления ~ Дополнение; инвертирует биты значений & Побитовое И | Побитовое включающее ИЛИ ^ Побитовое исключающее ИЛИ << Сдвиг влево; сдвигает биты значения влево на указанное количество разрядов >> Сдвиг вправо; сдвигает биты значения вправо на указанное количество разрядов
СТАРШИНСТВО ОПЕРАЦИЙ
При выполнении арифметических операций в C++ необходимо знать, что C++ выполняет операции в определенном порядке, основанном на старшинстве операций. Например, операция умножения выполняется до сложения. Чтобы лучше понять старшинство операций, рассмотрите следующие выражения:
result =5+2*3;
В зависимости от порядка, в котором C++ выполняет умножение и сложение, результат будет разным:
result =5+2*3; =7*3; = 21; result =5+2*3; =5+6; = 11;
Чтобы избежать путаницы, C++ присваивает каждой операции приоритет, который определяет порядок выполнения операций. Так как C++ выполняет операции в определенном порядке, то и ваши программы будут проводить арифметические вычисления соответствующим образом.
Таблица 5.3 перечисляет старшинство операций C++. Операции, находящиеся в верхней части, имеют более высокий приоритет. Операции внутри каждой части имеют одинаковый приоритет. Если вы рассмотрите таблицу, то увидите, что в C++ умножение имеет более высокий приоритет, чем сложение. Вы не знакомы со многими операциями, представленными в таблице. В настоящее время не думайте об этих операциях. К концу изучения этой книги вы сможете использовать (и понять) каждую из них!
Таблица 5.3. Старшинство операций в C++. Операция Имя Пример
:: Разрешение области видимости classname::classmember_name
:: Глобальное разрешение ::variable_name
. Выбор элемента object.member_name
-> Выбор элемента pointer->membername
[] Индексация pointer[element]
() Вызов функции expression(parameters)
() Построение значения type(parameters)
sizeof Размер объекта sizeof expression
sizeof Размер типа sizeof(type)
++ Приращение после variable++
++ Приращение до ++variable
-- Уменьшение после variable--
-- Уменьшение до -- variable
& Адрес объекта &variable
* Разыменование *pointer
new Создание (размещение) new type
delete Уничтожение (освобождение) delete pointer
delete[] Уничтожение массива delete pointer
~ Дополнение ~expression
! Логическое НЕ ! expression
+ Унарный плюс +1
- Унарный минус -1
() Приведение (type) expression
.* Выбор элемента object.*pointer
-> Выбор элемента object->*pointer
* Умножение expression * expression
/ Деление expression / expression
% Взятие по модулю expression % expression
+ Сложение (плюс) expression + expression
- Вычитание (минус) expression expression
Управление порядком, в котором C++ выполняет операции
Как вы уже знаете, C++ назначает операциям различный приоритет, который и управляет порядком выполнения операций. К сожалению, иногда порядок, в котором C++ выполняет арифметические операции, не соответствует порядку, в котором вам необходимо их выполнить. Например, предположим, что вашей программе необходимо сложить две стоимости и затем умножить результат на налоговую ставку:
cost = price_a + price_b * 1.06;
К сожалению, в этом случае C++ сначала выполнит умножение (price_b * 1.06), а затем прибавит значение price_a.
Если ваши программы должны выполнять арифметические операции в определенном порядке, вы можете заключить выражение в круглые скобки. Когда C++ оценивает выражение, он сначала всегда выполняет операции, сгруппированные в круглых скобках. Например, рассмотрим следующее выражение:
result =(2+3)* (3+4);
C++ вычисляет данное выражение в следующем порядке:
Подобным образом группируя выражения внутри круглых скобок, вы можете управлять порядком, в котором C++ выполняет арифметические операции. Аналогично предыдущему примеру, ваша программа может сложить две стоимости внутри круглых скобок, как показано ниже:
cost = (price_a + price_b) * 1.06; СЛЕДИТЕ ЗА ОШИБКАМИ ПЕРЕПОЛНЕНИЯ ПРИ АРИФМЕТИЧЕСКИХ ОПЕРАЦИЯХ
Из урока 4 вы узнали, что, если вы присваиваете переменной значение, которое не входит в диапазон значений для данного типа переменной, возникает ошибка переполнения. При выполнении арифметических операций необходимо помнить о возможности возникновения ошибок переполнения. Например, следующая программа MATHOVER.CPP умножает 200 на 300 и присваивает результат переменной типа int. Однако, поскольку результат умножения (60000) превышает наибольшее возможное значение для типа int (32767), возникает ошибка переполнения:
#include <iostream.h>
void main(void)
{ int result; result = 200 * 300; cout << "200 * 300 = " << result << endl; }
Когда вы откомпилируете и запустите эту программу, на экране появится следующий вывод:
С:\> MATHOVER <ENTER>
200 * 300 = -5536 ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ
В данном уроке вы изучали обычные арифметические операции и операции приращения C++. Чтобы программы корректно выполняли арифметические вычисления, C++ назначает каждой операции приоритет, который управляет порядком выполнения операций. Из урока 6 вы узнаете, как использовать входной поток с именем cin для выполнения операций ввода с клавиатуры. До изучения урока 6 убедитесь, что вы освоили следующее: C++ использует операторы +,- , * и / для сложения, вычитания, умножения и деления. C++ обеспечивает префиксные (до) и постфиксные (после) операции увеличения, которые прибавляют единицу к значению переменной. C++ обеспечивает префиксную (до) и постфиксную (после) операции уменьшения, которые вычитают единицу из значения переменной. Префиксные (до) операции указывают C++ сначала увеличить (или уменьшить) значение переменной, а затем использовать это значение. Постфиксные (после) операции указывают C++ сначала использовать значение переменной, а затем увеличить (или уменьшить) его. Чтобы гарантировать, что выражения выполняются корректно, C++ назначает каждой операции приоритет, управляющий порядком выполнения операций. Если вам нужно управлять порядком выполнения арифметических операций, используйте круглые скобки. C++ всегда вычисляет сначала выражение в скобках.
