Как вывести дробное число в c

Как вывести дробное число в c

Для этого делал всё то же самое для целых чисел и всё работало. А сейчас, когда при компиляции ввожу дробное число в х, а потом хочу ввести игрек, то у меня сразу он считает и причем y=сложение чисел которые я ввел в икс. хотя я одно число ввожу а не два. а он думает что 2 видимо.

мне кажется что проблема в int main
может быть float main, или это вообще всё не так надо.
извините, я только учусь.

Изображения

	Безымянный.png (7.6 Кб, 206 просмотров)
	2.jpg (12.0 Кб, 132 просмотров)

Регистрация: 22.05.2007
Сообщений: 9,518

Пробуйте вводить целые числа или у дроби другой разделитель ставьте (я уже не помню там, или .) перед вводом игрика можно буфер cin очистить, чтобы ничего автоматом в переменную не лезло и запрашивалось у пользователя.
Ну, и sum сначала посчитать нужно, а потом выводить.

Пользователь
Регистрация: 28.04.2010
Сообщений: 40
как сказал товарищ pu4koff выше, нужно сначала посчитать, а потом выводить

#include #include using namespace std; int main(void) < float x, y, sum; cout > x; cout > y; sum = x + y; cout

Похожие темы
Тема	Автор	Раздел	Ответов	Последнее сообщение
Ошибка int main()	Пиу Пиуу	Общие вопросы C/C++	14	08.11.2014 13:33
операция мод применимо к типу float,проверка числа- целое или дробное	all_is_fear	Помощь студентам	3	17.11.2011 16:16
функция float average(int arrray[],int from,int to)	yuliyayuliya	Помощь студентам	0	25.04.2011 21:55
error: ‘::main’ must return ‘int’	Without Soul	Общие вопросы C/C++	9	24.03.2011 07:26
Ошибка`main’ must return `int’	Hichigo	Общие вопросы C/C++	9	26.02.2011 15:33

Вывести дробное число прописью

Для вывода прописью дробного числа используется функция встроенного языка ЧислоПрописью(). Данная функция, принимает на вход параметр «ПараметрыПредметаИсчисления». С помощью этого параметра можно задать наименования целой и дробной части в разных падежах. Так как дробная часть может содержать разное количество знаков, то наименования целой и дробной части необходимо задавать в зависимости от этого количества.

Функция ПолучитьДробноеЧислоПрописью()

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

Пример
ВыводимоеЧисло — 32.400567899
Результат — «Тридцать две целых четыреста миллионов пятьсот шестьдесят семь тысяч восемьсот девяносто девять миллиардных»

Функция ПолучитьДробноеЧислоПрописью(ВыводимоеЧисло) 
 
ДробнаяЧасть = ВыводимоеЧисло - Цел(ВыводимоеЧисло); 
КоличествоЗнаков = ?(ДробнаяЧасть = 0, 0, СтрДлина(ДробнаяЧасть) - 2); 
 
Если КоличествоЗнаков = 1 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|десятая, десятых, десятых, ж, 1"; 
ИначеЕсли КоличествоЗнаков = 2 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|сотая, сотых, сотых, ж, 2"; 
ИначеЕсли КоличествоЗнаков = 3 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|тысячная, тысячных, тысячных, ж, 3"; 
ИначеЕсли КоличествоЗнаков = 4 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|десятитысячная, десятитысячных, 
|десятитысячных, ж, 4"; 
ИначеЕсли КоличествоЗнаков = 5 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|стотысячная, стотысячных, стотысячных, ж, 5"; 
ИначеЕсли КоличествоЗнаков = 6 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|миллионная, миллионных, миллионных, ж, 6"; 
ИначеЕсли КоличествоЗнаков = 7 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|десятимиллионная, десятимиллионных, 
|десятимиллионных, ж, 7"; 
ИначеЕсли КоличествоЗнаков = 8 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|стомиллионная, стомиллионных, 
|стомиллионных, ж, 8"; 
ИначеЕсли КоличествоЗнаков = 9 Тогда 
ПараметрыПредметаИсчисления = "целая, целых, целых, ж, 
|миллиардная, миллиардных, миллиардных, ж, 9"; 
Иначе 
ПараметрыПредметаИсчисления = ". 0"; 
КонецЕсли; 
 
Возврат ЧислоПрописью(ВыводимоеЧисло, "Л=ru_RU; ДП=Истина", ПараметрыПредметаИсчисления); 

КонецФункции 

Комментарии (0)

О сайте

Обратная связь

Правила

Новости 1С

Copyright © 2024 Цитирование материалов (тексты, изображения, программный код) допускается только с размещением активной ссылки на сайт 1CLenta.ru

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

В этом руководстве описаны числовые типы в 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: "); Console.WriteLine($"remainder: "); 

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

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

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

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

Обратите внимание, что ответ очень близок к минимальному целому числу (отрицательное значение). Он совпадает со значением 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 to "); 

Значения выводятся в экспоненциальном представлении. Число слева от символа 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 to "); 

Обратите внимание, что диапазон меньше, чем для типа 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# см. в следующих статьях:

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

Совместная работа с нами на GitHub

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

Числовые типы с плавающей запятой (справочник по C#)

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

Характеристики типов с плавающей запятой

C# поддерживает следующие предварительно определенные типы с плавающей запятой:

Ключевое слово или тип C#	Приблизительный диапазон значений	Точность	Размер	Тип .NET
float	От ±1,5 x 10 −45 до ±3,4 x 10 38	6–9 цифр	4 байта	System.Single
double	от ±5,0 × 10 −324 до ±1,7 × 10 308	15–17 цифр	8 байт	System.Double
decimal	от ±1,0 x 10 -28 до ±7,9228 x 10 28	28-29 знаков	16 байт	System.Decimal

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

double a = 12.3; System.Double b = 12.3; 

По умолчанию все типы с плавающей запятой имеют значение 0 . Все типы с плавающей запятой имеют константы MinValue и MaxValue с минимальным и максимальными итоговыми значениями этого типа. Типы float и double также предоставляют константы, обозначающие бесконечные и нечисловые значения. Например, тип double предоставляет следующие константы: Double.NaN, Double.NegativeInfinity и Double.PositiveInfinity.

Тип decimal подходит, если требуемая степень точности определяется числом цифр справа от десятичной запятой. Такие числа обычно используются в финансовых приложениях для денежных сумм (например, 1,00 долл. США), процентных ставок (например, 2,625 %) и т. д. Даже числа, точные только до одной десятичной цифры, точнее обрабатываются типом decimal : 0,1, например, можно в точности представить экземпляром decimal . При этом не существует экземпляра double или float , который точно представляет 0,1. Из-за этой разницы в числовых типах в арифметических вычислениях могут возникать непредвиденные ошибки округления при использовании double или float для десятичных данных. Вы можете использовать double вместо decimal , если оптимизация производительности важнее, чем обеспечение точности. Но любая разница в производительности останется незамеченной для всех приложений, кроме самых требовательных к вычислениям. Еще одна возможная причина, по которой следует избегать decimal , — это минимальные требования к хранилищу. Например, ML.NET использует float , так как разница между 4 байтами и 16 байтами суммируется для очень больших наборов данных. Для получения дополнительной информации см. System.Decimal.

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

• Если в выражении есть тип double , оно оценивается как double или bool в реляционных сравнениях или сравнениях на равенство.
• Если в выражении нет типа double , оно оценивается как float или bool в реляционных сравнениях или сравнениях на равенство.

Можно также смешивать целочисленные типы и тип decimal в выражении. В этом случае целочисленные типы неявно преобразуются в тип decimal , а выражение вычисляется как decimal или bool в реляционных сравнениях и сравнениях на равенство.

Тип decimal нельзя смешивать с типами float и double в выражении. В этом случае, если требуется выполнить арифметические операции или операции сравнения или равенства, необходимо явно преобразовать операнды из типа или в тип decimal , как показано в следующем примере:

double a = 1.0; decimal b = 2.1m; Console.WriteLine(a + (double)b); Console.WriteLine((decimal)a + b); 

Можно использовать строки стандартных числовых форматов или строки пользовательских числовых форматов для форматирования значения с плавающей запятой.

Вещественные литералы

Тип реального литерала определяется его суффиксом следующим образом:

• Литерал без суффикса или с суффиксом d или D имеет тип double .
• Литерал с суффиксом f или F имеет тип float .
• Литерал с суффиксом m или M имеет тип decimal .

В приведенном ниже коде показан пример каждого из них.

double d = 3D; d = 4d; d = 3.934_001; float f = 3_000.5F; f = 5.4f; decimal myMoney = 3_000.5m; myMoney = 400.75M; 

В предыдущем примере также показано использование _ в качестве разделителя цифр. Цифровой разделитель можно использовать со всеми видами числовых литералов.

Можно также использовать экспоненциальное представление, то есть указать экспоненту вещественного литерала, как показано в следующем примере:

double d = 0.42e2; Console.WriteLine(d); // output 42 float f = 134.45E-2f; Console.WriteLine(f); // output: 1.3445 decimal m = 1.5E6m; Console.WriteLine(m); // output: 1500000 

Преобразования

Существует только одно неявное преобразование между числовыми типами с плавающей запятой: из float в double . Однако можно преобразовать любой тип с плавающей запятой в любой другой тип с плавающей запятой с помощьюявного приведения. Для получения дополнительной информации см. статью Встроенные числовые преобразования.

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

• Типы с плавающей запятой
• Тип decimal
• Вещественные литералы

См. также

• справочник по C#
• Типы значений
• Целочисленные типы
• Строки стандартных числовых форматов
• Числовые значения в .NET
• System.Numerics.Complex

Совместная работа с нами на GitHub

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