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

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

Изучив это руководство, вы:

• Запустите пространство кода GitHub с помощью среды разработки C#.
• Изучите целочисленную математику.
• Учиться порядку выполнения операций.
• Узнайте об ограничениях целых чисел и их точности.
• Изучите типы данных с плавающей запятой.
• Узнайте о десятичном типе.

Предпосылки

У вас должно быть одно из следующих элементов:

• Учетная запись GitHub для использования GitHub Codespaces. Если у вас еще нет учетной записи, вы можете создать бесплатную учетную запись на GitHub.com.
• Компьютер со следующими инструментами:
  • Пакет SDK для .NET 10.
  • Visual Studio Code.
  • C# DevKit.

Изучение целочисленной математики

Чтобы запустить GitHub Codespace с средой учебника, откройте окно браузера в репозитории пространства кода учебника . Нажмите зеленую кнопку "Код" и вкладку "Пространства кода ". Затем выберите + знак, чтобы создать новое пространство Codespace с помощью этой среды. Если вы завершили учебник hello world , вы можете открыть это пространство кода вместо создания нового.

1. При загрузке пространства кода создайте новый файл в папке учебников с именем numbers.cs.

2. Откройте новый файл.

3. Введите или скопируйте следующий код в numbers.cs:

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

4. Запустите этот код, введя следующие команды в интегрированном терминале:

   cd ./tutorials
   dotnet numbers.cs
   

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

   • Символ - для вычитания
   • * для умножения
   • / для деления

5. Начните с изучения этих различных операций. Добавьте эти строки после строки, которая записывает значение c:

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

6. Запустите этот код, введя dotnet numbers.cs в окне терминала.

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

Совет

При изучении C# (или любого языка программирования) при написании кода могут возникать ошибки. Компилятор находит эти ошибки и сообщает им вам. Если выходные данные содержат сообщения об ошибках, внимательно изучите пример кода и код в окне, чтобы узнать, что нужно исправить. Вы также можете попросить Copilot найти различия или обнаружить ошибки. Это упражнение поможет вам узнать структуру кода 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);
}

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

1. Закомментируйте вызов WorkingWithIntegers(). Это делает выходные данные менее загромождными при работе в этом разделе:

   //WorkWithIntegers();
   

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

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

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

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

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

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

4. Исследуйте больше, комбинируя различные операции. Добавьте примерно следующие строки. Повторите попытку dotnet numbers в окне терминала.

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

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

5. Если вы не видите это поведение, попробуйте выполнить следующий код:

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

6. Введите dotnet numbers.cs еще раз в окне терминала, чтобы просмотреть результаты.

Прежде чем перейти, давайте рассмотрим весь код, который вы написали в этом разделе, и поместим его в новый метод. Вызовите этот новый метод 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);
}

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

В предыдущем примере показано, что целочисленное деление усекает результат. Остаток можно получить с помощью оператора остатка, символа %.

1. Попробуйте выполнить следующий код после вызова 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}");
   

2. Целочисленный тип C# отличается от математических целых чисел другим способом: тип int имеет минимальные и максимальные ограничения. Попробуйте просмотреть эти ограничения в следующем коде:

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

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

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

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

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

Работа с двойным типом

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

1. Добавьте следующий код и просмотрите результат:

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

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

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

   double a = 19;
   double b = 23;
   double c = 8;
   double d = (a + b) / c;
   Console.WriteLine(d);
   

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

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

   Эти значения печатаются в научной нотации. Число слева E от знака. Число справа является экспонентой, как мощность 10.

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

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

   Вы знаете, что 0.3 - это 3/10, а не совсем совпадает с 1/3. Аналогичным образом 0.33 — это 33/100. Это значение ближе к 1/3, но по-прежнему не точно. Независимо от того, сколько десятичных разрядов вы добавляете, остается ошибка округления.

челлендж

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

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

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

1. Давайте посмотрим:

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

   Обратите внимание, что диапазон меньше типа double.

2. Вы можете увидеть большую точность с десятичным типом, выполнив следующий код:

   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.

челлендж

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

Вы должны получить ответ от 19 до 20.

При попытке откройте область сведений, чтобы узнать, как вы сделали:

double radius = 2.50;
double area = Math.PI * radius * radius;
Console.WriteLine(area);

Попробуйте использовать другие формулы, если вы хотите.

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

• целочисленные числовые типы
• Числовые типы с плавающей запятой
• встроенные числовые преобразования

Очистка ресурсов

GitHub автоматически удаляет пространство Codespace через 30 дней бездействия. Если вы планируете ознакомиться с дополнительными руководствами в этой серии, вы можете оставить ваш Codespace активным. Если вы готовы посетить сайт .NET , чтобы скачать пакет SDK для .NET, можно удалить пространство Codespace. Чтобы удалить ваш Codespace, откройте окно браузера и перейдите к вашим Codespaces. В окне отобразится список ваших codespaces. Выберите три точки (...) в записи для пространства кода учебника для обучения и выберите удалить.

Следующий шаг

Кортежи и типы