Использование целочисленных чисел и чисел с плавающей запятой в C#

Статья
04/11/2023

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

Совет

Чтобы вставить фрагмент кода в режим фокусировки , используйте сочетание клавиш (CTRL + v или cmd + v).

Предварительные требования

Для работы с руководством вам потребуется компьютер, настроенный для разработки в локальной среде. Инструкции по установке и общие сведения о разработке приложений в .NET см. в статье Настройка локальной среды .

Если вы не хотите настраивать локальную среду, ознакомьтесь с интерактивной версией этого руководства в браузере.

Вычисления с целыми числами

Создайте каталог с именем numbers-quickstart. Сделайте его текущим и выполните следующую команду:

dotnet new console -n NumbersInCSharp -o .

Важно!

В шаблонах C# для .NET 6 используются операторы верхнего уровня. Приложение может не соответствовать коду, приведенному в этой статье, если вы уже выполнили обновление до .NET 6. Дополнительные сведения см. в статье Новые шаблоны C# для создания инструкций верхнего уровня.

Пакет SDK для .NET 6 также добавляет набор неявныхglobal using директив для проектов, использующих следующие пакеты SDK:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Эти неявные директивы global using включают наиболее распространенные пространства имен для соответствующего типа проектов.

Дополнительные сведения см. в статье о директивах неявного использования.

Откройте файл Program.cs в любом редакторе и замените содержимое файла следующим кодом:

int a = 18;
int b = 6;
int c = a + b;
Console.WriteLine(c);

Чтобы выполнить этот код, введите dotnet run в окно командной строки.

Вы увидели одну из основных математических операций с целыми числами. Тип int представляет целое положительное или отрицательное число или ноль. Для сложения используйте символ +. Другие стандартные математические операции с целыми числами включают:

- — вычитание;
* — умножение;
/ — деление.

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

// subtraction
c = a - b;
Console.WriteLine(c);

// multiplication
c = a * b;
Console.WriteLine(c);

// division
c = a / b;
Console.WriteLine(c);

Чтобы выполнить этот код, введите dotnet run в окно командной строки.

Можно также поэкспериментировать, написав несколько математических операций в одной строке. Например, выполните c = a + b - 12 * 17;. Допускается сочетание переменных и постоянных чисел.

Совет

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

Вы завершили первый этап. Прежде чем перейти к следующему разделу, переместим текущий код в отдельный метод. Метод — это последовательность инструкций, сгруппированных под одним именем. Чтобы вызвать метод, нужно указать имя метода и () после него. Упорядочение кода в методы упростит работу с новым примером. В результате ваш код должен выглядеть примерно следующим образом:

WorkWithIntegers();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

Строка WorkWithIntegers(); вызывает метод. Код после этой строки объявляет метод и определяет его.

Изучение порядка операций

Закомментируйте вызов WorkingWithIntegers(). Это поможет упорядочить выходные данные в этом разделе.

//WorkWithIntegers();

// запускает комментарий в C#. Комментарии — это любой текст, который должен быть сохранен в исходном коде, но не должен выполняться как код. Компилятор не создает исполняемый код из комментариев. Так как WorkWithIntegers() является методом, необходимо закомментировать только одну строку.

Язык C# определяет приоритет математических операций в соответствии с правилами математики. Умножение и деление имеют приоритет над сложением и вычитанием. Убедитесь в этом, добавив следующий код после вызова WorkWithIntegers() и выполнив dotnet run:

int a = 5;
int b = 4;
int c = 2;
int d = a + b * c;
Console.WriteLine(d);

В выходных данных видно, что умножение выполняется раньше сложения.

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

d = (a + b) * c;
Console.WriteLine(d);

Поэкспериментируйте, объединяя различные операции. Добавьте строки, как показано ниже. Выполните dotnet run еще раз.

d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
Console.WriteLine(d);

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

Если вы еще не видели пример такого поведения, выполните следующий код:

int e = 7;
int f = 4;
int g = 3;
int h = (e + f) / g;
Console.WriteLine(h);

Выполните dotnet run еще раз, чтобы просмотреть результаты.

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

// WorkWithIntegers();
OrderPrecedence();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

void OrderPrecedence()
{
    int a = 5;
    int b = 4;
    int c = 2;
    int d = a + b * c;
    Console.WriteLine(d);

    d = (a + b) * c;
    Console.WriteLine(d);

    d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
    Console.WriteLine(d);

    int e = 7;
    int f = 4;
    int g = 3;
    int h = (e + f) / g;
    Console.WriteLine(h);
}

Изучение точности и ограничений для целых чисел

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

int a = 7;
int b = 4;
int c = 3;
int d = (a + b) / c;
int e = (a + b) % c;
Console.WriteLine($"quotient: {d}");
Console.WriteLine($"remainder: {e}");

Тип целых чисел C# характеризуется еще одним отличием от математических целых: тип int имеет минимальные и максимальные ограничения. Чтобы просмотреть эти ограничения, добавьте такой код:

int max = int.MaxValue;
int min = int.MinValue;
Console.WriteLine($"The range of integers is {min} to {max}");

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

int what = max + 3;
Console.WriteLine($"An example of overflow: {what}");

Обратите внимание, что ответ очень близок к минимальному целому числу (отрицательное значение). Он совпадает со значением min + 2. Оператор сложения вызвал переполнение допустимых значений для целых чисел. Ответ является очень большим отрицательным числом, так как переполнение покрывает диапазон от наибольшего целого числа до наименьшего.

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

Работа с типом double

Числовой тип double представляет число с плавающей запятой двойной точности. Эти термины могут быть новыми для вас. Число с плавающей запятой можно использовать для представления нецелых чисел, которые могут быть очень большими или малыми. Число двойной точности — это относительный термин, описывающий количество двоичных разрядов, используемых для хранения значения. Числа двойной точности имеют в два раза больше двоичных символов по сравнению с числами одиночной точности. На современных компьютерах числа двойной точности используются чаще, чем одиночной. Числа одиночной точности объявляются с помощью ключевого слова float. Рассмотрим их. Добавьте следующий код и просмотрите результат:

double a = 5;
double b = 4;
double c = 2;
double d = (a + b) / c;
Console.WriteLine(d);

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

double e = 19;
double f = 23;
double g = 8;
double h = (e + f) / g;
Console.WriteLine(h);

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

double max = double.MaxValue;
double min = double.MinValue;
Console.WriteLine($"The range of double is {min} to {max}");

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

double third = 1.0 / 3.0;
Console.WriteLine(third);

Вы знаете, что 0.3 повторяющееся конечное число раз не совпадает с 1/3.

Задача

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

Работа с десятичными типами

Вы уже ознакомились с базовыми числовыми типами в C# — целыми числами и числами типа double. Осталось изучить еще один тип: decimal. Тип decimal имеет меньший диапазон, но большую точность, чем double. Например:

decimal min = decimal.MinValue;
decimal max = decimal.MaxValue;
Console.WriteLine($"The range of the decimal type is {min} to {max}");

Обратите внимание, что диапазон меньше, чем для типа double. Вы можете убедиться в повышении точности при использовании типа decimal, выполнив следующий код:

double a = 1.0;
double b = 3.0;
Console.WriteLine(a / b);

decimal c = 1.0M;
decimal d = 3.0M;
Console.WriteLine(c / d);

Суффикс M возле чисел указывает, что для константы должен использоваться тип decimal. В противном случае компилятор предполагает тип double.

Примечание

Буква M была выбрана потому, что визуально показывает различия между ключевыми словами double и decimal.

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

Задача

Теперь, когда вы ознакомились с разными числовыми типами, напишите код, который позволяет вычислить площадь круга с радиусом 2,50 см. Помните, что площадь круга равна квадрату радиуса, умноженному на число пи. Подсказка: в .NET есть константа пи Math.PI, которую можно использовать. Math.PI, как и все константы, объявленные в пространстве имен System.Math, — это значение double. По этой причине вместо значений decimal для этой задачи следует использовать double.

Вы должны получить ответ от 19 до 20. Ответ можно просмотреть в готовом примере кода на GitHub.

При желании поэкспериментируйте с другими формулами.

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

Дополнительные сведения о числах в C# см. в следующих статьях: