Как определить, целое ли число?
Лучше всегда использовать double (float только для хранения в больших массивах).
Давно C++ не использовал, но на сколько я помню такие вещи делаются через оператор привидения типов:
Все другие привидения — это что-то унаследованное от С . В С++ для каждого случая есть свой оператор.
Для проверки встроенных типов данный подход не подойдет. В различных компиляторах есть макросы, например, __typeof__ . Они специфичны для конкретного компилятора.
C++ Поддерживает урезанный RTTI. Возможно использовать только языковые возможности C++ , посмотрите на этот код:
Для этого надо подключить math.h.
Некоторые могут возразить, что сравнивать числа с плавающей запятой на равенство неправильно. Но если бы это было неправильно всегда, компилятор бы такое в принципе не позволял. В данном случае целые числа могут быть представлены точно в double. Операции сложения, вычитания и умножения для целых чисел также дадут целые числа, так как не вносят погрешностей округления. Для чисел, заданных вручную или полученных таким способом, проверка выше сработает корректно. Если всё же нужно проверить, что число целое в пределах некоторой погрешности eps (например 0.000001), можно использовать следующую проверку:
Или если в используемой версии стандартной библиотеки доступна функция round:
Эти два варианта используют округление к ближайшему целому, чтобы разность между этим и исходным числом была в интервале (-0.5; 0.5], а не [0; 1), как в случае округления к меньшему.
Как определить, целое ли число?
Давно C++ не использовал, но на сколько я помню такие вещи делаются через оператор привидения типов:
Все другие привидения — это что-то унаследованное от С . В С++ для каждого случая есть свой оператор.
Для проверки встроенных типов данный подход не подойдет. В различных компиляторах есть макросы, например, __typeof__ . Они специфичны для конкретного компилятора.
C++ Поддерживает урезанный RTTI. Возможно использовать только языковые возможности C++ , посмотрите на этот код:
Лучше всегда использовать double (float только для хранения в больших массивах).
Для этого надо подключить math.h.
Некоторые могут возразить, что сравнивать числа с плавающей запятой на равенство неправильно. Но если бы это было неправильно всегда, компилятор бы такое в принципе не позволял. В данном случае целые числа могут быть представлены точно в double. Операции сложения, вычитания и умножения для целых чисел также дадут целые числа, так как не вносят погрешностей округления. Для чисел, заданных вручную или полученных таким способом, проверка выше сработает корректно. Если всё же нужно проверить, что число целое в пределах некоторой погрешности eps (например 0.000001), можно использовать следующую проверку:
Или если в используемой версии стандартной библиотеки доступна функция round:
Эти два варианта используют округление к ближайшему целому, чтобы разность между этим и исходным числом была в интервале (-0.5; 0.5], а не [0; 1), как в случае округления к меньшему.
Как проверить, является ли число целым в .NET?
Скажем, у меня есть строка, содержащая число. Я хочу проверить, целое ли это число.
Примеры
3 ответы
Вы можете использовать int.TryParse. Он вернет логическое значение, если сможет проанализировать строку и установить для параметра out значение
ответ дан 11 окт ’08, 16:10
Этот ответ верен только в том случае, если число всегда будет от -2,147,483,648 2,147,483,647 16 XNUMX до XNUMX XNUMX XNUMX XNUMX. Если он больше, вам понадобится long.TryParse (). НАПРИМЕР: XNUMX-значный номер кредитной карты . — Райан Сэмпсон
Есть два немедленных варианта, которые вы можете использовать.
Вариант 1 — привилегированный — использовать Int32.TryParse.
int — C ++ определяет, является ли число целым числом
У меня есть программа на C ++, где я делю два числа, и мне нужно знать, является ли ответ целым числом или нет. Я использую это:
Я также попробовал это:
Проблема в том, что ответом обычно является 5-значное число, но со многими десятичными знаками. Например, ответом может быть: 58696.000000000000000025658 и программа считает, что это целое число.
Есть ли способ, которым я могу сделать эту работу?
Я делю double a/double b= double answer
(иногда больше 30 знаков после запятой)
РЕДАКТИРОВАТЬ:
a и b — это числа в тысячах (около 100 000), которые затем возводятся в степени 2 и 3, складываются и делятся (согласно сложной формуле). Поэтому я подключаю различные значения a и b и смотрю на ответ. Я оставлю только значения a и b, которые делают ответ целым числом. Примером того, что я получил за один из ответов, был 218624, который моя программа выше считала целым числом, но на самом деле это было: 218624.00000000000000000056982 Так что мне нужен код, который может различать целые числа с более чем 20-30 десятичными знаками.
Решение
Ты можешь использовать std::modf в cmath.h :
Неотъемлемая часть answer хранится в fraction и возвращаемое значение std::modf является дробной частью answer с тем же знаком, что и answer ,
Другие решения
Обычное решение — проверить, находится ли число на очень коротком расстоянии от целого числа, например так:
Это необходимо, потому что числа с плавающей запятой имеют ограниченную точность, и числа, которые на самом деле являются целыми числами, могут не отображаться идеально. Например, следующее не получится, если мы сделаем прямое сравнение:
Вот, answer на самом деле имеет значение 0.99999. , поэтому мы не можем сравнить это с целым числом и не можем проверить, близка ли дробная часть к 0.
В общем, поскольку представление числа с плавающей запятой может быть немного меньше или немного больше, чем фактическое число, не следует проверять, близка ли дробная часть к 0. Это может быть число, подобное 0.99999999 или же 0.000001 (или даже их негативы), это все возможные результаты потери точности. Вот почему я проверяю обе стороны ( +epsilon а также -epsilon ). Вы должны отрегулировать это epsilon переменная, чтобы соответствовать вашим потребностям.
Кроме того, имейте в виду, что точность double близко к 15 цифр . Вы также можете использовать long double , что может дать вам некоторые дополнительные цифры точности (или нет, это зависит от компилятора), но даже это только поможет вам 18 цифр . Если вам нужно больше точности, вам нужно будет использовать внешнюю библиотеку, например GMP .
Числа с плавающей запятой хранятся в памяти с использованием совсем другого формата битов, чем целые числа. Из-за этого сравнение их на равенство вряд ли будет работать эффективно. Вместо этого вам нужно проверить, если разница меньше, чем некоторые эпсилон:
В качестве альтернативы, если вы хотите включить значения, близкие к целым числам (в зависимости от желаемой точности), вы можете слегка изменить условие if (так как остаток возвращается std::fmod будет в диапазоне [0, 1) ):
Вы можете увидеть тест для этого Вот .
Числа с плавающей запятой, как правило, несколько точны до 12-15 цифр (как double ), но, поскольку они хранятся как мантисса (дробь) и показатель степени, рациональные числа (целые или обычные дроби) вряд ли будут храниться как таковые. Например,
Из-за этого вам нужно сравнить разницу ожидаемого с некоторым очень небольшим числом, которое включает в себя точность, которую вы хотите (мы назовем это значение, эпсилон):
Поэтому, когда вы пытаетесь сравнить остаток от std::fmod нужно проверить на разницу 0.0 (не для фактического равенства 0.0 ), что и делается выше.
Так же std::fabs Вызов call предотвращает необходимость двух проверок, утверждая, что значение всегда будет положительным.
Если вам нужна точность, превышающая 15-18 десятичных знаков, вы не можете использовать double или же long double ; вам нужно будет использовать высокоточную библиотеку с плавающей точкой.