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

Основные математические операторы

Основными математическими операторами в языке программирования C# являются:

  • Сложение (+)
  • Вычитание (-)
  • Умножение (*)
  • Деление (/)
  • Остаток от деления (%)

Рассмотрим пример простейшего приложения:

using System;
using System.Text;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Настройка кодировки, если используется Английская версия Windows.
            Console.OutputEncoding = Encoding.Unicode;

            // Запрашиваем у пользователя входные данные.
            var first = InputNumber();
            var second = InputNumber();

            // Сумма.
            var sum = first + second;
            Console.WriteLine($"Результат сложения {first} и {second} равен {sum}.");

            // Разность.
            var sub = first - second;
            Console.WriteLine($"Результат вычитания {first} и {second} равен {sub}.");

            // Умножение.
            var mul = first * second;
            Console.WriteLine($"Результат умножения {first} и {second} равен {mul}.");

            // Деление на цело.
            var dev = first / second;
            Console.WriteLine($"Результат деления на цело {first} и {second} равен {dev}.");

            // Дробное деление.
            var devd = (double)first / second;
            Console.WriteLine($"Результат деления дробного {first} и {second} равен {devd}.");

            // Остаток от деления.
            var mod = first % second;
            Console.WriteLine($"Результат остатка от деления {first} и {second} равен {mod}.");

            // Ожидаем ввода пользователя.
            Console.ReadLine();
        }

        /// <summary>
        /// Запросить у пользователя на ввод целое число.
        /// </summary>
        /// <returns> Целое число, введенное пользователем. </returns>
        private static int InputNumber()
        {
            // Повторяем запрос до тех пор, пока пользователь ни введет корректные данные.
            while (true)
            {
                // Делаем запрос на консоль и сохраняем введенные пользователем данные в текстовом формате.
                Console.Write("Введите число: ");
                var input = Console.ReadLine();

                // Пробуем преобразовать введенные пользователь данные в целое число.
                if (int.TryParse(input, out int inputNumber))
                {
                    // Если преобразование удалось, то возвращаем результат.
                    return inputNumber;
                }

                // Иначе сообщаем пользователю об ошибке.
                Console.WriteLine("Некорректный ввод. Пожалуйста, введите целое число.");
            }
        }
    }
}

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

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

Так же стоит упомянуть операцию остатка от деления, про которую многие забывают. В других языках она часто записывается как mod. Она означает, что результатом будет число, оставшееся неподеленным при целочисленном делении. Для примера 5 % 2 = 1, это означает, что было выполнено целочисленное деление ближайшего меньшего подходящего числа — 4. А результатом является разница этого числа и исходного 5 — 4 = 1.

Операторы инкремента

Существует особая группа операторов, которая называется инкрементной. Особенность этих операторов заключается в том, что они изменяю значение которое хранится в самой переменной. Вот наиболее часто используемые инкрементные операторы:

  • Увеличение значения переменной на 1 (++)
  • Уменьшение значения на 1 (—)
  • Увеличение значения переменной на заданное значение (+=)
  • Уменьшение переменной на заданное значение (-=)
  • Умножение переменной на значение (*=)
  • Деление переменной на значение (/=)

С точки зрения работы приложения все приведенные ниже записи являются идентичными, но инкрементные операторы являются более компактными при написании исходного кода приложения.

int i = 20;

i = i + 1;
i += 1;
i++;

Или другой пример, когда если мы хотим умножить текущее значение переменной на 4, то это можно записать так:

var j = 7;
j *= 4;
Console.WriteLine(j);
Префиксная и постфиксная запись инкремента

Обратите внимание, что существуют две формы записи:

  • Префиксная — когда оператор инкремента ставится перед именем переменной (++i)
  • Постфиксная — когда оператор инкремента ставится после имени переменной (i++)

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

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = 0;
            int m = 0;

            int i = 0;
            int j = 0;

            n = i++;
            m = ++j;
            Console.WriteLine($"n = {n}");
            Console.WriteLine($"m = {m}");
            Console.WriteLine($"i = {i}");
            Console.WriteLine($"j = {j}");
            Console.ReadLine();
        }
    }
}

Как вы видите, результат переменных n и m отличаются. Это связано с тем, что при постфиксной записи сначала выполнилось присвоение значения переменной i (0) в переменную n (0), а после этого было выполнено увеличение значение переменной i на единицу (1). При префиксной записи, сначала выполнилось увеличение значения переменной j (1), а после этого присвоение переменной m (1).

Сложение (конкатенация) строк

Если со сложением чисел все достаточно просто, то как будет вести себя язык C# при попытке сложения, вычитания, умножения и деления строк? На самом деле все достаточно просто, для строк доступна только одна операция это сложение, а если быть точнее конкатенация. Конкатенация — это операция склеивания двух строк в одну новую стоку, содержащую обе исходные подстроки. Рассмотрим пример:

string str1 = "Hello";
string str2 = "World";
string strresult = str1 + " " + str2;
Console.WriteLine(strresult);
Console.ReadLine();

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

Приоритет выполнения операторов

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

int i = 2 + 2 * 2;
int j = (2 + 2) * 2;

Console.WriteLine($"i = {i}");
Console.WriteLine($"j = {j}");
Console.ReadLine();

Заключение

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

Вконтакте
Facebook
Telegram
Twitter
Одноклассники
Дзен
Google+

 
×
%d такие блоггеры, как: