Как сделать сумму чисел в c
Как и в 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, только когда ввод отличается.
Теперь, как мы можем обнаружить перенос? Давайте посмотрим таблицу истинности керри.
При внимательном рассмотрении мы замечаем, что таблица истинности суммы и 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;
Читайте также: