Из урока 4 вы узнали, как объявлять и использовать переменные в своих программах. По мере усложнения программ вы будете выполнять арифметические операции, такие как сложение, вычитание, умножение и деление, над значениями, содержащимися в переменных. Данный урок описывает, как использовать арифметические операторы 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 для вывода реультата нескольких простых арифметических операций:
#include <iostream.h>
void main(void)
{
cout << "5 + 7 = " << 5 + 7 << endl;
cout << "12 - 7 = " << 12 - 7 << endl;
cout << "1.2345 * 2 = " << 1.23.45 * 2 << endl;
cout << "15 / 3 = " << 15 / 3 << endl;
}
Посмотрите внимательно на операторы программы. Обратите внимание, что каждое выражение сначала появляется в кавычках, которые обеспечивают вывод символов (например, 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 к значению целой переменной. Например, предположим, что ваша программа использует переменную с именем count, чтобы сохранить данные о количестве напечатанных файлов. Каждый раз, когда программа печатает файл, 1 будет добавляться к текущему значению count. Используя оператор присваивания C++, ваша программа может увеличивать значение count, как показано ниже:
count = count + 1;
В данном случае программа сначала выбирает значение count, а затем добавляет к нему единицу. Далее программа записывает результат сложения обратно в переменную count. Следующая программа INTCOUNT.CPP использует оператор присваивания для увеличения переменной count (которая первоначально содержит значение 1000) на единицу (присваивая переменной результат 1001):
#include <iostream.h>
void main(void)
{
int count = 1000;
cout << "начальное значение count равно" << count << endl;
count = count + 1;
cout << "конечное значение count равно" << count << endl;
}
Когда вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
С:\> 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++ выполняет арифметические операции, не соответствует порядку, в котором вам необходимо их выполнить. Например, предположим, что вашей программе необходимо сложить две стоимости и затем умножить результат на налоговую ставку:
cost = price_a + price_b * 1.06;
К сожалению, в этом случае C++ сначала выполнит умножение (price_b * 1.06), а затем прибавит значение price_a.
Если ваши программы должны выполнять арифметические операции в определенном порядке, вы можете заключить выражение в круглые скобки. Когда C++ оценивает выражение, он сначала всегда выполняет операции, сгруппированные в круглых скобках. Например, рассмотрим следующее выражение:
result =(2+3)* (3+4);
C++ вычисляет данное выражение в следующем порядке:
result = (2 + 3) * (3 + 4);
= (5) * (3 + 4);
= 5 * (7);
=5*7;
= 35;
Подобным образом группируя выражения внутри круглых скобок, вы можете управлять порядком, в котором 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++ всегда вычисляет сначала выражение в скобках.