[Информация] Простые операции

Anоnymоus · 07.05.2012, 23:13

Для выполнения математических операций используйте в своих программах арифметические операторы C++.

Чтобы гарантировать последовательность операций, C++ назначает приоритет каждому оператору.
Используя круглые скобки в арифметических выражениях, вы можете управлять порядком, в котором C++ выполняет операции.
Многие программы на C++ прибавляют или вычитают единицу, используя операции увеличения (++) или уменьшения (--).

После того как вы научитесь распознавать разные арифметические операторы C++, вы поймете, что выполнять математические операции очень легко!

ОСНОВНЫЕ МАТЕМАТИЧЕСКИЕ ОПЕРАЦИИ

Независимо от назначения большинство ваших программ на C++ будут складывать, вычитать, умножать или делить. Вы узнаете, что ваши программы могут выполнять арифметические операции с константами (например, 3*5) или с переменными (например, payment — total). Таблица ниже перечисляет основные математические операции C++:

Код:

Операция          Назначение          Пример

+                 Сложение            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

Обычной операцией, которую вы будете выполнять при программировании, является прибавление 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++ выполняет операции в определенном порядке, то и ваши программы будут проводить арифметические вычисления соответствующим образом.

Таблица снизу перечисляет старшинство операций C++. Операции, находящиеся в верхней части, имеют более высокий приоритет. Операции внутри каждой части имеют одинаковый приоритет. Если вы рассмотрите таблицу, то увидите, что в 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++ вычисляет данное выражение в следующем порядке:

Код:

result = (2 + 3) * (3 + 4);
= (5) * (3 + 4);
= 5 * (7);
=5*7;
= 35;

Подобным образом группируя выражения внутри круглых скобок, вы можете управлять порядком, в котором C++ выполняет арифметические операции. Аналогично предыдущему примеру, ваша программа может сложить две стоимости внутри круглых скобок, как показано ниже:

Код:

cost = (price_a + price_b) * 1.06;

СЛЕДИТЕ ЗА ОШИБКАМИ ПЕРЕПОЛНЕНИЯ ПРИ АРИФМЕТИЧЕСКИХ ОПЕРАЦИЯХ

Вы знаете, что, если вы присваиваете переменной значение, которое не входит в диапазон значений для данного типа переменной, возникает ошибка переполнения. При выполнении арифметических операций необходимо помнить о возможности возникновения ошибок переполнения. Например, следующая программа 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++ назначает каждой операции приоритет, который управляет порядком выполнения операций.

Из данного урока вы узнали:

C++ использует операторы +,- , * и / для сложения, вычитания, умножения и деления.
C++ обеспечивает префиксные (до) и постфиксные (после) операции увеличения, которые прибавляют единицу к значению переменной.
C++ обеспечивает префиксную (до) и постфиксную (после) операции уменьшения, которые вычитают единицу из значения переменной.
Префиксные (до) операции указывают C++ сначала увеличить (или уменьшить) значение переменной, а затем использовать это значение.
Постфиксные (после) операции указывают C++ сначала использовать значение переменной, а затем увеличить (или уменьшить) его.
Чтобы гарантировать, что выражения выполняются корректно, C++ назначает каждой операции приоритет, управляющий порядком выполнения операций.
Если вам нужно управлять порядком выполнения арифметических операций, используйте круглые скобки. C++ всегда вычисляет сначала выражение в скобках.

P.S. Копипаст [Ссылки могут видеть только зарегистрированные пользователи. ].

~~e7n9~~ · 18.06.2012, 22:26

Тема с хорошим содержанием , примечание - лучше будет заключить в [code]

VeTaL_UA · 19.06.2012, 12:33

Тема была наглым тупоскопипащеным необработанным материалом с другого портала.

Копипасты поставлены. Тема оформлена. Автор награжден картами.

~~ralex~~ · 21.07.2012, 12:14

В примерах где используются операторы cin, cout после include`ов поставьте строку using namespace std; (для работников Visual Studio) или перед каждым оператором cin, cout, endl, ставьте std::
То есть std::endl, std::cin, std::cout.