Перейти к основному содержимому

Выполнение основных операций с числами в C#.

Цели обучения

После завершения этого модуля вы сможете:

  • Выполнять математические операции над числовыми значениями
  • Выполнять неявные преобразования типов между строками и числовыми значениями.
  • Временно преобразовать один тип данных в другой

Введение

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

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

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

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

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

Выполнение сложения с неявным преобразованием данных​

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

Сложение двух числовых значений​

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

В этом случае компилятор C# понимает, что вы пытаетесь сделать. Компилятор анализирует ваш код и видит, что (оператор) окружен двумя числовыми значениями (операндами). Учитывая типы данных переменных (обе целые), становится ясно, что вы намеревались сложить эти два значения.

int firstNumber = 12;
int secondNumber = 7;
Console.WriteLine(firstNumber + secondNumber);
19

Смешанные типы данных для принудительного неявного преобразования типов​

Что произойдет, если вы попытаетесь использовать символ + как со строковыми, так и с целочисленными значениями?

string firstName = "Bob";
int widgetsSold = 7;
Console.WriteLine(firstName + " sold " + widgetsSold + " widgets.");
Bob sold 7 widgets.

В этом случае компилятор C# понимает, что вы хотите использовать символ для объединения двух операндов. Это делается потому, что символ окружен операндами типов данных string и int. Таким образом, он пытается временно преобразовать переменную int widgetsSold в строку, чтобы можно было объединить ее с остальной частью строки. Компилятор C# пытается помочь вам, когда может, но в идеале вы должны четко заявить о своих намерениях.

Попробуйте более сложный вариант сложения чисел и объединения строк​

string firstName = "Bob";
int widgetsSold = 7;
Console.WriteLine(firstName + " sold " + widgetsSold + 7 + " widgets.");
Bob sold 77 widgets.

Вместо добавления переменной int widgetsSold к литералу int 7 компилятор рассматривает все как строку и объединяет все это вместе.

Добавьте круглые скобки, чтобы уточнить ваше намерение компилятору.​

string firstName = "Bob";
int widgetsSold = 7;
Console.WriteLine(firstName + " sold " + (widgetsSold + 7) + " widgets.");
Bob sold 14 widgets.

Символ скобок () становится еще одним перегруженным оператором. В этом случае открывающая и закрывающая круглые скобки образуют оператор порядка операций, точно так же, как вы можете использовать его в математической формуле. Вы указываете, что хотите, чтобы сначала были разрешены самые внутренние круглые скобки, что привело к добавлению целочисленных значений widgetsSold и значения 7. Как только это будет разрешено, он неявно преобразует результат в строку, чтобы его можно было объединить с остальной частью сообщение.

:::

примечание

Вам следует избегать выполнения вычислений и объединения в одной строке кода. Цель здесь — помочь вам понять, как просматривать операторы и операнды так, как это делает компилятор.

Вот что вы уже узнали о математических операциях в C#​

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

Математические операции​

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

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

Напишите код для выполнения сложения, вычитания, умножения и деления целых чисел​

int sum = 7 + 5;
int difference = 7 - 5;
int product = 7 * 5;
int quotient = 7 / 5;

Console.WriteLine("Sum: " + sum);
Console.WriteLine("Difference: " + difference);
Console.WriteLine("Product: " + product);
Console.WriteLine("Quotient: " + quotient);
Sum: 12
Difference: 2
Product: 35
Quotient: 1

Как вы видете: + — оператор сложения, - это оператор вычитания, * — оператор умножения, / — оператор деления.

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

Добавьте код для выполнения деления с использованием буквенных десятичных данных​

Чтобы деление работало правильно, вам необходимо использовать тип данных, который поддерживает дробные цифры после десятичной точки, например decimal

decimal decimalQuotient = 7.0m / 5;
Console.WriteLine($"Decimal quotient: {decimalQuotient}");
Decimal quotient: 1.4

Чтобы это работало, частное (слева от оператора присваивания) должно иметь тип decimal, и хотя бы одно из делимых чисел также должно иметь тип decimal (оба числа также могут быть типом decimal).

Однако следующие строки кода не будут работать (или давать неточные результаты):

int decimalQuotient = 7 / 5.0m;
int decimalQuotient = 7.0m / 5;
int decimalQuotient = 7.0m / 5.0m;
decimal decimalQuotient = 7 / 5;

Добавьте код для преобразования результатов целочисленного деления​

Что делать, если вы не работаете с литеральными значениями? Другими словами, что, если вам нужно разделить две переменные типа int, но вы не хотите, чтобы результат усекался? В этом случае вам необходимо выполнить приведение типа данных от int к decimal. Приведение — это один из типов преобразования данных, который предписывает компилятору временно обрабатывать значение так, как если бы оно имело другой тип данных.

Чтобы привести int к decomal, вы добавляете оператор приведения перед значением. Для приведения имени типа данных перед значением используется имя типа данных, заключенное в круглые скобки. В этом случае вы должны добавить (decimal) перед первой и второй переменными.

int first = 7;
int second = 5;
decimal quotient = (decimal)first / (decimal)second;
Console.WriteLine(quotient);
1.4

:::

примечание

Вы видели три варианта использования оператора скобки: вызов метода, порядок операций и приведение типов.

Напишите код для определения остатка после целочисленного деления​

Оператор модуля % сообщает вам остаток от деления int. Из этого вы действительно узнаете, делится ли одно число на другое. Это может быть полезно во время длительных операций обработки, когда вы просматриваете сотни или тысячи записей данных и хотите предоставить конечным пользователям обратную связь после обработки каждых 100 записей данных.

Console.WriteLine($"Modulus of 200 / 5 : {200 % 5}");
Console.WriteLine($"Modulus of 7 / 5 : {7 % 5}");
Modulus of 200 / 5 : 0
Modulus of 7 / 5 : 2

Когда модуль равен 0, это означает, что делимое делится на делитель нацело.

Порядок действий​

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

Порядок следующий:

  1. круглые скобки (все, что находится внутри скобок, выполняется в первую очередь)
  2. показатели степени
  3. умножение и деление (слева направо)
  4. сложение и вычитание (слева направо)

В математике PEMDAS — это аббревиатура, которая помогает учащимся запомнить порядок операций.

  1. Parentheses (whatever is inside the parenthesis is performed first)
  2. Exponents
  3. Multiplication and Division (from left to right)
  4. Addition and Subtraction (from left to right)

C# следует тому же порядку, что и PEMDAS, за исключением экспонент. Хотя в C# нет оператора экспоненты, вы можете использовать метод System.Math.Pow. В модуле «Вызов методов из библиотеки классов .NET с использованием C#» будет представлен этот и другие методы.

Напишите код для реализации порядка операций C#​

int value1 = 3 + 4 * 5;
int value2 = (3 + 4) * 5;
Console.WriteLine(value1);
Console.WriteLine(value2);

Здесь вы видите разницу при выполнении одних и тех же операций в разном порядке.

23
35

Вот что вы уже узнали о математических операциях в C#:​

  1. Используйте такие операторы, как +, -, * и /, для выполнения основных математических операций.
  2. Деление двух целочисленных значений приведет к усечению любых значений после десятичной точки. Чтобы сохранить значения после десятичной точки, вам необходимо сначала преобразовать делитель или делимое (или оба) из целого числа в число с плавающей запятой, например десятичное, затем частное также должно быть того же типа с плавающей запятой, чтобы избежать усечения.
  3. Выполните операцию приведения, чтобы временно обработать значение так, как будто оно имеет другой тип данных.
  4. Используйте оператор %, чтобы получить остаток после деления.
  5. Порядок операций будет соответствовать правилам аббревиатуры PEMDAS.\

Значения инкремента и декремента​

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

Инкремент и декремент​

Часто вам придется увеличивать и/или уменьшать значения, особенно когда вы пишете логику цикла или код, который взаимодействует со структурой данных.

Оператор += добавляет и присваивает значение справа от оператора значению слева от оператора. Итак, вторая и третья строки в следующем фрагменте кода одинаковы:

int value = 0;     // value is now 0.
value = value + 5; // value is now 5.
value += 5;        // value is now 10.

Оператор ++ увеличивает значение переменной на 1. Таким образом, вторая и третья строки в следующем фрагменте кода одинаковы:

int value = 0;     // value is now 0.
value = value + 1; // value is now 1.
value++;           // value is now 2.

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

:::

примечание

Такие операторы, как +=, -=, *=, ++ и --, известны как составные операторы присваивания, поскольку они объединяют некоторые операции в дополнение к присвоению результата переменной. Оператор += специально называется оператором сложения и присваивания.

Напишите код для увеличения и уменьшения значения​

int value = 1;

value = value + 1;
Console.WriteLine("First increment: " + value);

value += 1;
Console.WriteLine("Second increment: " + value);

value++;
Console.WriteLine("Third increment: " + value);

value = value - 1;
Console.WriteLine("First decrement: " + value);

value -= 1;
Console.WriteLine("Second decrement: " + value);

value--;
Console.WriteLine("Third decrement: " + value);
First increment: 2
Second increment: 3
Third increment: 4
First decrement: 3
Second decrement: 2
Third decrement: 1

:::

примечание

Во «втором приращении» вы использовали значение += 1;. Однако вы могли бы использовать любое буквальное значение int (или переменную), чтобы увеличить эту сумму. То же самое справедливо и для «второго декремента»: value -= 1;.

Размещение операторов увеличения и уменьшения.​

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

Используйте оператор приращения до и после значения​

int value = 1;
value++;
Console.WriteLine("First: " + value);
Console.WriteLine($"Second: {value++}");
Console.WriteLine("Third: " + value);
Console.WriteLine("Fourth: " + (++value));
First: 2
Second: 2
Third: 3
Fourth: 4

Обратите внимание на эту строку кода:

Console.WriteLine($"Second: {value++}");

В этой строке есть два шага:

  • Получите текущее значение переменной value и используйте его в операции интерполяции строки.
  • Увеличьте значение.

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

Console.WriteLine("Third: " + value);

Для сравнения рассмотрим последнюю строку кода:

Console.WriteLine("Fourth: " + (++value));

Здесь порядок операций переключается, поскольку оператор ++ ставится перед значением операнда.

  • Увеличьте значение.
  • Получите новое увеличенное значение переменной value и используйте его в строковой операции.

Хотя это и не является строго необходимым, вы добавили скобки вокруг выражения (значения), чтобы улучшить читаемость. Видеть так много операторов рядом друг с другом кажется, что это может быть неправильно понято другими разработчиками. Стилистические решения, подобные этому, субъективны. Однако, поскольку вы напишете код один раз, а прочитаете его много раз, вам следует уделять приоритетное внимание читабельности.