Как сделать сумму чисел в c

Обновлено: 06.07.2024

Как и в Delphi операторы делятся на две группы: унарные и бинарные.

++ (приращение),
-- (уменьшение),
+ (плюс) и — (минус)

* (умножение),
/ (деление),
% (остаток от деления),
+ (сложение) и — (вычитание).

Операторы приращения (++) и уменьшения (—)

Ближайшими аналогами в Delphi для этих операторов являются процедуры Inc() и Dec() .

Оператор инкремента ++ увеличивает операнд на 1, а оператор декремента -- , соответственно, уменьшает операнд на 1. При этом операндом должна быть переменная , свойство или индексатор.

Например, результатом выполнения вот такого кода:

Вроде бы все вполне себе логично — одну переменную увеличили на 1, вторую — уменьшили на 1 и вывели результат в виде строки.

Казалось бы, результат измениться не должен и строка должна быть той же, но нет. В результате мы получим:

То есть, переменные а и b получили первоначальные значения f и i . Почему так происходит?

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

Теперь, если взглянуть на пример выше, становится понятно поведение программы — мы использовали постфиксные операторы и в результате, вначале переменной a присваивается значение f , а уже потом значение переменной f увеличивается на 1. Аналогично происходит и с переменной b — она получает первоначальное значение i и только после этого i уменьшается на 1.

На первый взгляд может показаться странным, но вот такое действие:

Чтобы наше переменные получили измененные значения код надо переписать с использованием префиксной формы операторов, то есть вот так:

Результатом выполнения будет строка:

Унарные операторы плюса и минуса

Результатом будет строка:

Остается только отметить, что целочисленный тип ulong не поддерживает унарный минус. Если мы попытаемся сделать вот так:

То ещё до компиляции получим ошибку:

Выведет на экран следующее:

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

Умножение (*)

Оператор умножения * вычисляет произведение операндов, например:

вернет значение 50 , а типом данных для произведения будет, ожидаемо, int . Соответственно, в этом примере:

Программа вернет нам вещественный тип float (System.Single). Другое дело — оператор деления.

Деление (/)

Приведет к ошибке:

Чтобы код сработал без ошибок надо произвести приведение типов, а именно переписать код следующим образом:

и деление пройдет успешно с результатом

Остаток от деления (%)

Для целочисленных операндов результатом a % b является значение полученное из выражения a - (a / b) * b . Знак ненулевого остатка такой же, как и у левого операнда, например:

В Delphi с оператором mod такое проделать нельзя. Для получения аналогичного результата нам бы пришлось воспользоваться функцией FMod() из модуля Math .

Операторы сложения (+) и вычитания (-)

Операторы составного присваивания

где op — какой-либо из рассмотренных выше операторов. Читается такое выражение в развернутом виде следующим образом:

вернет нам значения, которые написаны в комментариях к коду, то есть строки:

Из-за восходящих приведений результат операции op может быть невозможно неявно преобразовать в тип T из x. В этом случае, если op является предопределенным оператором, и результат операции является явно преобразуемым в тип T``x, выражение составного присваивания формы x op= y эквивалентно x = (T)(x op y), за исключением того, что x вычисляется только один раз.

Пример такого поведения представлен там же в справке:

Мы бы, возможно, ожидали, что последний вывод в консоль содержал бы число 300 , но тип byte у нас только от 0 до 255. В результате в вывод попало значение ( 300-256 = 44 ).

Приоритет и ассоциативность операторов

Арифметические операторы выполняются в следующем порядке (по убыванию приоритета):

Постфиксный инкремент x++ и декремент x--
Префиксный инкремент ++x и декремент --x , унарные операторы + и -
Мультипликативные операторы * , / , и %
Аддитивные операторы + и -

Бинарные арифметические операторы имеют левую ассоциативность. То есть операторы с одинаковым приоритетом вычисляются в направлении слева направо.

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

Итого

На этом уроке мы рассмотрим арифметические операторы и их использование в языке С++.

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

Унарные операторы — это операторы, которые применяются только к одному операнду. Существуют два унарных арифметических оператора: плюс ( + ) и минус ( − ).

Оператор	Символ	Пример	Операция
Унарный плюс	+	+x	Значение x
Унарный минус	−	−x	Отрицательное значение x

Унарный оператор + возвращает значение операнда. Другими словами, +5 = 5 или +х = х . Унарный плюс вам, скорее всего, не придется использовать. Его по большей части добавили в качестве симметрии с унарным оператором минус. Унарный оператор минус возвращает операнд, умноженный на −1 . Например, если х = 5 , то −х = −5 .

Оба этих оператора пишутся непосредственно перед самим операндом, без пробела ( −x , а не − x ).

Не следует путать унарный оператор минус с бинарным оператором вычитания, хоть они и используют один и тот же символ. Например, в выражении х = 5 − −3; , первый минус — это оператор вычитания, а второй — унарный минус.

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

Бинарные операторы — это операторы, которые применяются к двум операндам (слева и справа). Существует 5 бинарных операторов.

Оператор	Символ	Пример	Операция
Сложение	+	x + y	x плюс y
Вычитание	−	x − y	x минус y
Умножение	*	x * y	x умножить на y
Деление	/	x / y	x разделить на y
Деление с остатком	%	x % y	Остаток от деления x на y

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

Деление целых чисел и чисел типа с плавающей точкой

Оператор деления имеет два режима. Если оба операнда являются целыми числами, то оператор выполняет целочисленное деление. Т.е. любая дробь (больше/меньше) отбрасывается и возвращается целое значение без остатка, например, 7 / 4 = 1 .

Если один или оба операнда типа с плавающей точкой, то тогда будет выполняться деление типа с плавающей точкой. Здесь уже дробь присутствует. Например, выражения 7.0 / 3 = 2.333 , 7 / 3.0 = 2.333 или 7.0 / 3.0 = 2.333 имеют один и тот же результат.

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

Использование оператора static_cast в операциях деления

На уроке о символьном типе данных char мы уже использовали оператор static_cast для вывода ASCII-символов в виде целых чисел.

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

std :: cout "double / double crayon-h"> static_cast double > ( x ) / static_cast double > ( y ) "\n" ;

Результат выполнения программы:

int / int = 1
double / int = 1.75
int / double = 1.75
double / double = 1.75

Деление с остатком

Оператор деления с остатком ( % ) работает только с целочисленными операндами и возвращает остаток от целочисленного деления. Например:

Пример №1: 7 / 4 = 1 с остатком 3 , таким образом, 7 % 4 = 3 .

Пример №2: 25 / 7 = 3 с остатком 4 , таким образом, 25 % 7 = 4 . Остаток составляет не дробь, а целое число.

Пример №3: 36 % 5 = 7 с остатком 1 . В числе 36 только 35 делится на 5 без остатка, поэтому 36 − 35 = 1 , 1 — это остаток и результат.

Данный оператор чаще всего используют для проверки деления без остатка одних чисел на другие. Если х % у == 0 , то х делится на у без остатка.

Например, мы хотим написать программу, которая выводит числа от 1 до 100 по 20 значений в каждой строке. Мы можем использовать оператор деления с остатком для создания разрыва строк. Несмотря на то, что мы еще не рассматривали цикл while, в следующей программе всё максимально просто и понятно:

Результат выполнения программы:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100

О while мы еще поговорим на соответствующем уроке.

Отрицательные числа в операциях деления до C++11

До C++11, если любой из операндов целочисленного деления является отрицательным, то компилятор округляет результат самостоятельно! Например, результатом −5 / 2 может быть либо −3 , либо −2 . Однако большинство современных компиляторов округляют числа в сторону нуля (например, в −5 / 2 результатом будет −2 ). В спецификации C++11 определили, что компилятор должен всегда округлять к нулю (или, проще говоря, просто отбрасывать дробь).

Также до C++11, если один из операндов оператора деления с остатком является отрицательным, то результат может быть как положительным, так и отрицательным! Например, результатом −5 % 2 может быть как 1 , так и −1 . В спецификации C++11 решили сделать так, чтобы результат a % b был того же знака, что и значение а .

Арифметические операторы присваивания

Оператор	Символ	Пример	Операция
Присваивание	=	x = y	Присваиваем значение y переменной x
Сложение с присваиванием	+=	x += y	Добавляем y к x
Вычитание с присваиванием	−=	x −= y	Вычитаем y из x
Умножение с присваиванием	*=	x *= y	Умножаем x на y
Деление с присваиванием	/=	x /= y	Делим x на y
Деление с остатком и с присваиванием	%=	x %= y	Присваиваем остаток от деления x на y переменной x

До этого момента, когда нам нужно было добавить число 5 к определенной переменной, мы делали следующее:

Учитывая два целых числа a и b, как мы можем оценить сумму a + b без использования таких операторов, как +, -, ++, -,…?

Метод 1 (Использование указателей)
Интересный способ будет:

// Может не работать с компиляторами C ++ и
// может выдавать предупреждения на C.

// Возвращает сумму 'a' и 'b'

int sum( int a, int b)

Несмотря на неловкость с первого взгляда, мы можем легко понять, что происходит. Сначала мы создали указатель p. Значение указателя является адресом памяти. В этом случае значением p является адрес a.

Помните: р указывает на положение а. В этом примере, если мы хотим узнать значение позиции a (999), мы просим * p. Если мы хотим узнать адрес переменной a (41), мы просим & a.

Если бы мы вычислили p [b], мы бы получили значение памяти в позиции p + b. Фактически, мы оцениваем & p [b], ведь это то же самое, что и получение адреса p + b без доступа к его значению. Поскольку p = a, & p [b] вернет адрес a + b.

Мы не хотим возвращать адрес памяти (int *). Мы хотим вернуть целое число (int). Итак, мы приводим & p [b] к int.

Это sizeof (* p) учитывает количество позиций, которые каждая переменная занимает в памяти.

Мы хотим оценить p + b. Другими словами, мы хотим, чтобы sizeof (* p) равнялся 1. Следовательно, если * p — символ, мы счастливы.

Метод 2 (Использование побитовых операторов)
Давайте посмотрим таблицу истинности суммы (простите за перенос):

При внимательном рассмотрении мы замечаем, что таблица истинности суммы и xor одинакова. Это 1, только когда ввод отличается.

Теперь, как мы можем обнаружить перенос? Давайте посмотрим таблицу истинности керри.

Внимательно посмотрев еще раз, мы заметим, что таблица переноса, логика и таблица истинности идентичны. Теперь нам нужно сместить a & 1 влево и суммировать с помощью a ^ b. Тем не менее, эта операция также может иметь переносы. Нет проблем, просто сложите a ^ b с рекурсивным смещением & 1 влево.

// Возвращает сумму a и b используя побитовый
// операторы.

int sum( int a, int b)

if (carry == 0) return s;

else return sum(s, carry

Это решение обсуждалось здесь .

Способ 3 (с использованием printf)
Давайте вспомним некоторые факты:

Имея это в виду, мы можем понять эту функцию:

// Возвращает сумму a и b, используя printf
// Ограничения: a, b> 0.

int sum( int a, int b)

return printf ( "%*c%*c" , a, '\r' , b, '\r' );

Это решение обсуждалось здесь .

Пожалуйста, напишите комментарии, если вы обнаружите что-то неправильное, или вы хотите поделиться дополнительной информацией по обсуждаемой теме

for(int i = 0; i Нравится Показать список оценивших

using namespace std;

void main()
<
setlocale(LC_ALL, "Rus");
int a, b, c;

cout « "Введите 3 числа чтобы получить их сумму,умножаемое и среднее арифметическое:";

cout « "Ответы: " « " Сложение: "« a + b + c « " Умножение: "« a * b * c « " Среднее арифметическое: "« (a + b + c) / 3 «endl;

cout « "Программа для вычисления суммы, произведения и среднего арифметического значения, введенных Вами трех чисел!" « "\n\n";

cout « endl « "Сумма введенных чисел: " « a + b + c « endl;
cout « "Произведение введенных чисел: " « a * b * c « endl;
cout « "Среднее арифметическое введенных чисел: " « (a + b + c) / 3 « "\n\n";
>

void main()
<
setlocale(LC_ALL, "Rus");

d = a + b + c;
cout « "Сумма ваших чисел равна " « d « endl;

d = a * b * c;
cout « "Произведение ваших чисел равно " « d « endl;

d = (a + b + c) / 3;
cout « "Среднее арифметическое ваших чисел равно " « d « endl;

Читайте также: