.net - разница - отличие float от double c++




Разница между десятичной, плавающей и двойной в.NET? (11)

В чем разница между decimal , float и double в .NET?

Когда кто-нибудь воспользуется одним из них?


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

float ~ ± 1,5 x 10-45 до ± 3,4 × 1038 -------- 7 цифр
двойной ~ ± 5,0 × 10-324 ± 1,7 × 10308 ------ 15 или 16 цифр
десятичная ~ ± 1,0 × 10-28 до ± 7,9 × 1028 -------- 28 или 29 цифр


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


Никто не упомянул, что

В настройках по умолчанию Floats (System.Single) и double (System.Double) никогда не будут использовать проверку переполнения, в то время как Decimal (System.Decimal) всегда будет использовать проверку переполнения.

Я имею в виду

decimal myNumber = decimal.MaxValue;
myNumber += 1;

выбрасывает OverflowException .

Но это не так:

float myNumber = float.MaxValue;
myNumber += 1;

&

double myNumber = double.MaxValue;
myNumber += 1;

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

Dim fMean as Double = 1.18
Dim fDelta as Double = 0.08
Dim fLimit as Double = 1.1

If fMean - fDelta < fLimit Then
    bLower = True
Else
    bLower = False
End If

Вопрос: Какое значение содержит переменная bLower?

Ответ: На 32-битной машине bLower содержит TRUE !!!

Если я заменил Double на Decimal, bLower содержит FALSE, что является хорошим ответом.

В двойном случае проблема заключается в том, что fMean-fDelta = 1.09999999999, что ниже, чем 1.1.

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

Фактически, Double, Float и Decimal соответствуют BINARY десятичному значению в COBOL!

К сожалению, другие числовые типы, реализованные в COBOL, не существуют в .Net. Для тех, кто не знает COBOL, существуют в COBOL следующие числовые типы

BINARY or COMP like float or double or decimal
PACKED-DECIMAL or COMP-3 (2 digit in 1 byte)
ZONED-DECIMAL (1 digit in 1 byte) 

Простыми словами:

  1. Типы переменных Decimal, Double и Float отличаются тем, что они сохраняют значения.
  2. Точность - основное различие (обратите внимание, что это не единственная разница), где float - это тип данных с плавающей точкой с одной точностью (32 бит), double - это тип данных с плавающей точкой с двойной точностью (64 бит), а десятичный - это 128-битный тип данных с плавающей точкой.
  3. Сводная таблица:

/==========================================================================================
    Type       Bits    Have up to                   Approximate Range 
/==========================================================================================
    float      32      7 digits                     -3.4 × 10 ^ (38)   to +3.4 × 10 ^ (38)
    double     64      15-16 digits                 ±5.0 × 10 ^ (-324) to ±1.7 × 10 ^ (308)
    decimal    128     28-29 significant digits     ±7.9 x 10 ^ (28) or (1 to 10 ^ (28)
/==========================================================================================
Вы можете прочитать больше здесь , Float , Double и Decimal .


Точность - главное различие.

Float - 7 цифр (32 бит)

Double -15-16 цифр (64 бит)

Decimal -28-29 значащих цифр (128 бит)

Десятичные числа имеют гораздо более высокую точность и обычно используются в финансовых приложениях, требующих высокой степени точности. Десятичные числа намного медленнее (до 20 раз в некоторых тестах), чем двойной / плавающий.

Десятичные числа и поплавки / парные пары не могут сравниваться без броска, тогда как Floats and Doubles могут. Десятичные числа также допускают кодирование или конечные нули.

float flt = 1F/3;
double dbl = 1D/3;
decimal dcm = 1M/3;
Console.WriteLine("float: {0} double: {1} decimal: {2}", flt, dbl, dcm);

Результат:

float: 0.3333333  
double: 0.333333333333333  
decimal: 0.3333333333333333333333333333

Целые числа, как уже упоминалось, являются целыми числами. Они не могут хранить точку, например .7, .42 и .007. Если вам нужно хранить числа, которые не являются целыми числами, вам нужен другой тип переменной. Вы можете использовать тип double или float. Вы устанавливаете эти типы переменных точно так же: вместо использования слова int вы вводите double или float . Как это:

float myFloat;
double myDouble;

( float подходит для «плавающей запятой» и просто означает число с точкой что-то в конце.)

Разница между ними - это размер чисел, которые они могут удерживать. Для float вы можете иметь до 7 цифр в своем номере. Для double s вы можете иметь до 16 цифр. Если быть более точным, вот официальный размер:

float:  1.5 × 10^-45  to 3.4 × 10^38  
double: 5.0 × 10^-324 to 1.7 × 10^308

float - 32-разрядное число, а double - 64-разрядное число.

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

double myDouble;
myDouble = 0.007;
MessageBox.Show(myDouble.ToString());

Остановите свою программу и вернитесь в окно кодирования. Измените эту строку:

myDouble = 0.007;
myDouble = 12345678.1234567;

Запустите программу и нажмите двойную кнопку. В поле сообщения правильно отображается номер. Добавьте еще один номер в конец, и C # снова округляется вверх или вниз. Мораль - если вы хотите точности, будьте осторожны с округлением!


Я не буду повторять тонны хорошей (и некорректной) информации, на которую уже ответил ответ в других ответах и ​​комментариях, но я отвечу на ваш следующий вопрос с подсказкой:

Когда кто-нибудь воспользуется одним из них?

Использовать десятичное значение для подсчитанных значений

Используйте float / double для измеренных значений

Некоторые примеры:

  • деньги (мы считаем деньги или измеряем деньги?)

  • расстояние (мы рассчитываем расстояние или измеряем расстояние?)

  • (подсчитываем ли мы оценки или оцениваем баллы?)

Мы всегда считаем деньги и никогда не должны их измерять. Обычно мы измеряем расстояние. Мы часто подсчитываем баллы.

* В некоторых случаях, что я бы назвал номинальным расстоянием , мы можем действительно хотеть «подсчитать» расстояние. Например, возможно, мы имеем дело со знаками страны, которые показывают расстояния до городов, и мы знаем, что эти расстояния никогда не имеют более одной десятичной цифры (xxx.x км).


float 7 цифр точности

double имеет около 15 цифр точности

decimal цифра имеет около 28 цифр точности

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

Я нашел это интересным. Что каждый компьютерный ученый должен знать о арифметике с плавающей точкой


+---------+----------------+---------+----------+---------------------------------------------+
| C#      | .Net Framework | Signed? | Bytes    | Possible Values                             |
| Type    | (System) type  |         | Occupied |                                             |
+---------+----------------+---------+----------+---------------------------------------------+
| sbyte   | System.Sbyte   | Yes     | 1        | -128 to 127                                 |
| short   | System.Int16   | Yes     | 2        | -32768 to 32767                             |
| int     | System.Int32   | Yes     | 4        | -2147483648 to 2147483647                   |
| long    | System.Int64   | Yes     | 8        | -9223372036854775808 to 9223372036854775807 |
| byte    | System.Byte    | No      | 1        | 0 to 255                                    |
| ushort  | System.Uint16  | No      | 2        | 0 to 65535                                  |
| uint    | System.UInt32  | No      | 4        | 0 to 4294967295                             |
| ulong   | System.Uint64  | No      | 8        | 0 to 18446744073709551615                   |
| float   | System.Single  | Yes     | 4        | Approximately ±1.5 x 10-45 to ±3.4 x 1038   |
|         |                |         |          |  with 7 significant figures                 |
| double  | System.Double  | Yes     | 8        | Approximately ±5.0 x 10-324 to ±1.7 x 10308 |
|         |                |         |          |  with 15 or 16 significant figures          |
| decimal | System.Decimal | Yes     | 12       | Approximately ±1.0 x 10-28 to ±7.9 x 1028   |
|         |                |         |          |  with 28 or 29 significant figures          |
| char    | System.Char    | N/A     | 2        | Any Unicode character (16 bit)              |
| bool    | System.Boolean | N/A     | 1 / 2    | true or false                               |
+---------+----------------+---------+----------+---------------------------------------------+

Для получения дополнительной информации см.
http://social.msdn.microsoft.com/Forums/en-US/csharpgeneral/thread/921a8ffc-9829-4145-bdc9-a96c1ec174a5







decimal