С примеры арифметических программ

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

Для установки определенного бита необходимо соответствующий бит маски установить в 1 и произвести операцию побитового логического ИЛИ с константой, представляющей собой маску:

unsigned char a = 3;
a = a | 0x04; // a = 7, бит 2 установлен

Для сброса определенного бита необходимо соответствующий бит маски сбросить в 0 и произвести операцию побитового логического И с константой, представляющей собой инверсную маску:

unsigned char a = 3;
a = a // a = 1, бит 1 сброшен

Бинарные побитовые логические операции могут быть объединены с операцией присваивания:

• объект // объект = объект // объект = объект | выражение
• объект ^= выражение; // объект = объект ^ выражение

Сдвиговые операции

Операции арифметического сдвига применяются в целочисленной арифметике и обозначаются как:

Общий синтаксис осуществления операции сдвига:
объект = выражение сдвиг КоличествоРазрядов;

unsigned char a=6; // a = 0000 0110
unsigned char b;
b = a >> 1; // b = 0000 0110 >> 1 = 0000 0011 = 3

Арифметический сдвиг целого числа вправо >> на 1 разряд соответствует делению числа на 2.
Арифметический сдвиг целого числа влево на 1 разряд соответствует умножению числа на 2.

Комментариев к записи: 41

Источник: prog-cpp.ru

С примеры арифметических программ

Язык программирования Си поддерживает все основные арифметические операции. Эти операции производятся над числами. Значения, которые участвуют в операции, называются операндами. Список имеющихся в Си операций:

+ Операция сложения возвращает сумму двух чисел:

#include int main(void) < int a = 67; int b = 33; int c = a + b + 7; printf(«a + b + 7 = %d n», c); // 107 return 0; >
#include int main(void) < int a = 67; int b = 33; int c = a — b; printf(«a — b = %d n», c); // 34 return 0; >
int c = 15 * 3; // 45
#include int main(void) < int a = 15 / 3; // 5 float d = 34.0 / 3.0; // 11.333333 printf(«a=%d n», a); printf(«d=%f n», d); return 0; >

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

float f = 10 / 4; printf(«f = %f n», f); // 2.0

Результат представлял вещественное число, один из операндов также должен представлять вещественное число:

float f = 10.0 / 4; printf(«f = %f n», f); // 2.5
int a = 35 % 3; // 2 (35 — 33 = 2)

Операции *, /, % имеют больший приоритет, чем + и — :

int a = 8; int b = 7; int c = a + 5 * b; // 43 printf(«c = %d n», c); // 43

Здесь результатом будет число 43:

1. 5 * b = 35
2. a + 35 = 43

С помощью скобок мы можем переопределить порядок операций, сделав, чтобы операции с более низким приоритетом выполнялись до операций с более высоким приоритетом:

int a = 8; int b = 7; int c = (a + 5) * b; // 91

Здесь результатом будет число 91:

1. a + 5 = 13
2. 13 * b = 91

Также в Си есть специальные унарные операции над одним числом: ++ (инкремент) и — (декремент). Каждая из операций имеет две разновидности: префиксная и постфиксная.

Префиксный инкремент (++x). Увеличивает значение переменной на единицу и полученное значение используется как значение выражения ++x

int a = 8; int b = ++a; printf(«a = %d n», a); // 9 printf(«b = %d», b); // 9
int a = 8; int b = a++; printf(«a = %d n», a); // 9 printf(«b = %d», b); // 8
int a = 8; int b = —a; printf(«a = %d n», a); // 7 printf(«b = %d», b); // 7
int a = 8; int b = a—; printf(«a = %d n», a); // 7 printf(«b = %d», b); // 8

Рассмотрим более сложную ситуацию:

int a = 8; int b = 7; int c = a+++b; printf(«a = %d n», a); // 9 printf(«b = %d n», b); // 7 printf(«c = %d n», c); // 15

Здесь операция трактуются таким образом, что вначале идет постфиксный инкремент, а потом сложение. То есть фактически так:

int c = (a++) + b;

Аналогично будет расцениваться выражения с постфиксным декрементом: int c = a—b; .

Источник: metanit.com

5.2 – Арифметические операторы

В C++ есть два унарных арифметических оператора, плюс (+) и минус (-). Напоминаем, что унарные операторы – это операторы, которые принимают только один операнд.

Оператор унарного минуса возвращает операнд, умноженный на -1 . Другими словами, если x = 5 , -x равно -5 .

Оператор унарного плюса возвращает значение операнда. Другими словами, +5 равно 5 , а +x равно x . Как правило, вам не нужно использовать этот оператор, поскольку он избыточен. Он был добавлен в основном для обеспечения симметрии с унарным оператором минус.

Для наилучшего эффекта оба этих оператора следует размещать непосредственно перед операндом (например, -x , а не — x ).

Не путайте оператор унарного минуса с оператором бинарного вычитания, в котором используется тот же символ. Например, в выражении x = 5 — -3; первый минус – это оператор бинарного вычитания, а второй – оператор унарного минуса.

Бинарные арифметические операторы

В C++ есть 5 бинарных арифметических операторов. Бинарные операторы – это операторы, которые принимают левый и правый операнды.

Операторы сложения, вычитания и умножения работают так же, как и в реальной жизни, без каких-либо оговорок.

Деление и остаток от деления требуют дополнительных пояснений. О делении мы поговорим ниже, а об остатке от деления – в следующем уроке.

Целочисленное деление и деление с плавающей запятой

Проще всего представить себе, что оператор деления имеет два разных «режима».

Если один (или оба) операнда являются значениями с плавающей точкой, оператор деления выполняет деление с плавающей точкой. Деление с плавающей точкой возвращает значение с плавающей точкой, и дробная часть сохраняется. Например, 7.0 / 4 = 1.75 , 7 / 4.0 = 1.75 и 7.0 / 4.0 = 1.75 . Как и во всех арифметических операциях с плавающей точкой, здесь могут возникать ошибки округления.

Если оба операнда являются целыми числами, оператор деления вместо этого выполняет целочисленное деление. Целочисленное деление отбрасывает любые дробные части и возвращает целочисленное значение. Например, 7 / 4 = 1 , потому что дробная часть результата отбрасывается. Точно так же -7 / 4 = -1 , потому что дробная часть опускается.

Предупреждение

До C++11 целочисленное деление с отрицательным операндом могло округляться в большую или меньшую сторону. Таким образом, -5 / 3 могло дать результат -1 или -2 . Это было исправлено в C++11, где дробная часть всегда отбрасывается (округляется до 0).

Использование static_cast<> для деления с плавающей точкой с целочисленными значениями

Сказанное выше поднимает вопрос: если у нас есть два целых числа и мы хотим разделить их без потери дробной части, как нам это сделать?

В уроке «4.11 – Символы» мы показали, как можно использовать оператор static_cast<> для преобразования значения char в целочисленный тип, чтобы оно печаталось как целое число, а не как символ.

Аналогичным образом мы можем использовать static_cast<> для преобразования значения целочисленного типа в число с плавающей точкой, чтобы мы, вместо целочисленного деления, смогли выполнить деление с плавающей точкой. Рассмотрим следующий код:

#include int main() < int x< 7 >; int y< 4 >; std::cout (x) / y (y) int / int = 1 double / int = 1.75 int / double = 1.75 double / double = 1.75

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

Деление на ноль

Попытка разделить на 0 (или 0.0) обычно приводит к сбою программы, так как результаты математически не определены!

#include int main() < std::cout ; std::cin >> x; std::cout Арифметические операторы присваивания