Decimal.GetBits Метод
Определение
Важно!
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Перегрузки
| GetBits(Decimal) |
Преобразует значение заданного экземпляра Decimal в эквивалентное ему двоичное представление. |
| GetBits(Decimal, Span<Int32>) |
Преобразует значение заданного экземпляра Decimal в эквивалентное ему двоичное представление. |
GetBits(Decimal)
- Исходный код:
- Decimal.cs
- Исходный код:
- Decimal.cs
- Исходный код:
- Decimal.cs
Преобразует значение заданного экземпляра Decimal в эквивалентное ему двоичное представление.
public:
static cli::array <int> ^ GetBits(System::Decimal d);public static int[] GetBits (decimal d);static member GetBits : decimal -> int[]Public Shared Function GetBits (d As Decimal) As Integer()Параметры
- d
- Decimal
Преобразуемое значение.
Возвращаемое значение
Массив 32-разрядных целых чисел со знаком, состоящий из четырех элементов, в которых содержится двоичное представление параметра d.
Примеры
В следующем примере метод используется для GetBits преобразования нескольких Decimal значений в эквивалентные двоичные представления. Затем отображаются десятичные значения и шестнадцатеричное значение элементов в массиве, возвращаемом методом GetBits .
using namespace System;
int main()
{
// Define an array of Decimal values.
array<Decimal>^ values = gcnew array<Decimal> { Decimal::One,
Decimal::Parse("100000000000000"),
Decimal::Parse("10000000000000000000000000000"),
Decimal::Parse("100000000000000.00000000000000"),
Decimal::Parse("1.0000000000000000000000000000"),
Decimal::Parse("123456789"),
Decimal::Parse("0.123456789"),
Decimal::Parse("0.000000000123456789"),
Decimal::Parse("0.000000000000000000123456789"),
Decimal::Parse("4294967295.0"),
Decimal::Parse("18446744073709551615.0"),
Decimal::MaxValue, Decimal::MinValue,
Decimal::Parse("-7.9228162514264337593543950335") };
Console::WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"Argument", "Bits[3]", "Bits[2]", "Bits[1]", "Bits[0]" );
Console::WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"--------", "-------", "-------", "-------", "-------" );
for each (Decimal value in values)
{
array<int>^ bits = Decimal::GetBits(value);
Console::WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
value, bits[3], bits[2], bits[1], bits[0] );
}
}
/*
This example of the Decimal::GetBits( Decimal ) method
generates the following output. It displays the argument
as a Decimal and the result array in hexadecimal.
Argument Bits[3] Bits[2] Bits[1] Bits[0]
-------- ------- ------- ------- -------
1 00000000 00000000 00000000 00000001
100000000000000 00000000 00000000 00005AF3 107A4000
10000000000000000000000000000 00000000 204FCE5E 3E250261 10000000
100000000000000.00000000000000 000E0000 204FCE5E 3E250261 10000000
1.0000000000000000000000000000 001C0000 204FCE5E 3E250261 10000000
123456789 00000000 00000000 00000000 075BCD15
0.123456789 00090000 00000000 00000000 075BCD15
0.000000000123456789 00120000 00000000 00000000 075BCD15
0.000000000000000000123456789 001B0000 00000000 00000000 075BCD15
4294967295 00000000 00000000 00000000 FFFFFFFF
18446744073709551615 00000000 00000000 FFFFFFFF FFFFFFFF
79228162514264337593543950335 00000000 FFFFFFFF FFFFFFFF FFFFFFFF
-79228162514264337593543950335 80000000 FFFFFFFF FFFFFFFF FFFFFFFF
-7.9228162514264337593543950335 801C0000 FFFFFFFF FFFFFFFF FFFFFFFF
*/
using System;
class Example
{
public static void Main()
{
// Define an array of Decimal values.
Decimal[] values = { 1M, 100000000000000M, 10000000000000000000000000000M,
100000000000000.00000000000000M, 1.0000000000000000000000000000M,
123456789M, 0.123456789M, 0.000000000123456789M,
0.000000000000000000123456789M, 4294967295M,
18446744073709551615M, Decimal.MaxValue,
Decimal.MinValue, -7.9228162514264337593543950335M };
Console.WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"Argument", "Bits[3]", "Bits[2]", "Bits[1]",
"Bits[0]" );
Console.WriteLine( "{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"--------", "-------", "-------", "-------",
"-------" );
// Iterate each element and display its binary representation
foreach (var value in values) {
int[] bits = decimal.GetBits(value);
Console.WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
value, bits[3], bits[2], bits[1], bits[0]);
}
}
}
// The example displays the following output:
// Argument Bits[3] Bits[2] Bits[1] Bits[0]
// -------- ------- ------- ------- -------
// 1 00000000 00000000 00000000 00000001
// 100000000000000 00000000 00000000 00005AF3 107A4000
// 10000000000000000000000000000 00000000 204FCE5E 3E250261 10000000
// 100000000000000.00000000000000 000E0000 204FCE5E 3E250261 10000000
// 1.0000000000000000000000000000 001C0000 204FCE5E 3E250261 10000000
// 123456789 00000000 00000000 00000000 075BCD15
// 0.123456789 00090000 00000000 00000000 075BCD15
// 0.000000000123456789 00120000 00000000 00000000 075BCD15
// 0.000000000000000000123456789 001B0000 00000000 00000000 075BCD15
// 4294967295 00000000 00000000 00000000 FFFFFFFF
// 18446744073709551615 00000000 00000000 FFFFFFFF FFFFFFFF
// 79228162514264337593543950335 00000000 FFFFFFFF FFFFFFFF FFFFFFFF
// -79228162514264337593543950335 80000000 FFFFFFFF FFFFFFFF FFFFFFFF
// -7.9228162514264337593543950335 801C0000 FFFFFFFF FFFFFFFF FFFFFFFF
open System
// Define an list of Decimal values.
let values =
[ 1M; 100000000000000M; 10000000000000000000000000000M
100000000000000.00000000000000M; 1.0000000000000000000000000000M
123456789M; 0.123456789M; 0.000000000123456789M
0.000000000000000000123456789M; 4294967295M
18446744073709551615M; Decimal.MaxValue
Decimal.MinValue; -7.9228162514264337593543950335M ]
printfn $"""{"Argument",31} {"Bits[3]",10:X8}{"Bits[2]",10:X8}{"Bits[1]",10:X8}{"Bits[0]",10:X8}"""
printfn $"""{"--------",31} {"-------",10:X8}{"-------",10:X8}{"-------",10:X8}{"-------",10:X8}"""
// Iterate each element and display its binary representation
for value in values do
let bits = Decimal.GetBits value
printfn $"{value,31} {bits[3],10:X8}{bits[2],10:X8}{bits[1],10:X8}{bits[0],10:X8}"
// The example displays the following output:
// Argument Bits[3] Bits[2] Bits[1] Bits[0]
// -------- ------- ------- ------- -------
// 1 00000000 00000000 00000000 00000001
// 100000000000000 00000000 00000000 00005AF3 107A4000
// 10000000000000000000000000000 00000000 204FCE5E 3E250261 10000000
// 100000000000000.00000000000000 000E0000 204FCE5E 3E250261 10000000
// 1.0000000000000000000000000000 001C0000 204FCE5E 3E250261 10000000
// 123456789 00000000 00000000 00000000 075BCD15
// 0.123456789 00090000 00000000 00000000 075BCD15
// 0.000000000123456789 00120000 00000000 00000000 075BCD15
// 0.000000000000000000123456789 001B0000 00000000 00000000 075BCD15
// 4294967295 00000000 00000000 00000000 FFFFFFFF
// 18446744073709551615 00000000 00000000 FFFFFFFF FFFFFFFF
// 79228162514264337593543950335 00000000 FFFFFFFF FFFFFFFF FFFFFFFF
// -79228162514264337593543950335 80000000 FFFFFFFF FFFFFFFF FFFFFFFF
// -7.9228162514264337593543950335 801C0000 FFFFFFFF FFFFFFFF FFFFFFFF
Module Example
Public Sub Main()
' Define an array of decimal values.
Dim values() As Decimal = { 1d, 100000000000000d,
10000000000000000000000000000d,
100000000000000.00000000000000d,
1.0000000000000000000000000000d,
123456789d, 0.123456789d,
0.000000000123456789d,
0.000000000000000000123456789d,
4294967295d,
18446744073709551615d,
Decimal.MaxValue, Decimal.MinValue,
-7.9228162514264337593543950335d }
Console.WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"Argument", "Bits[3]", "Bits[2]", "Bits[1]",
"Bits[0]" )
Console.WriteLine( "{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"--------", "-------", "-------", "-------",
"-------" )
' Iterate each element and display its binary representation
For Each value In values
Dim bits() As Integer = Decimal.GetBits(value)
Console.WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
value, bits(3), bits(2), bits(1), bits(0))
Next
End Sub
End Module
' The example displays the following output:
'
' Argument Bits(3) Bits(2) Bits(1) Bits(0)
' -------- ------- ------- ------- -------
' 1 00000000 00000000 00000000 00000001
' 100000000000000 00000000 00000000 00005AF3 107A4000
' 10000000000000000000000000000 00000000 204FCE5E 3E250261 10000000
' 100000000000000.00000000000000 000E0000 204FCE5E 3E250261 10000000
' 1.0000000000000000000000000000 001C0000 204FCE5E 3E250261 10000000
' 123456789 00000000 00000000 00000000 075BCD15
' 0.123456789 00090000 00000000 00000000 075BCD15
' 0.000000000123456789 00120000 00000000 00000000 075BCD15
' 0.000000000000000000123456789 001B0000 00000000 00000000 075BCD15
' 4294967295 00000000 00000000 00000000 FFFFFFFF
' 18446744073709551615 00000000 00000000 FFFFFFFF FFFFFFFF
' 79228162514264337593543950335 00000000 FFFFFFFF FFFFFFFF FFFFFFFF
' -79228162514264337593543950335 80000000 FFFFFFFF FFFFFFFF FFFFFFFF
' -7.9228162514264337593543950335 801C0000 FFFFFFFF FFFFFFFF FFFFFFFF
В следующем примере метод используется GetBits для получения составных частей массива. Затем он использует этот массив в вызове конструктора Decimal(Int32, Int32, Int32, Boolean, Byte) для создания экземпляра нового Decimal значения.
using System;
public class Example
{
public static void Main()
{
Decimal[] values = { 1234.96m, -1234.96m };
foreach (var value in values) {
int[] parts = Decimal.GetBits(value);
bool sign = (parts[3] & 0x80000000) != 0;
byte scale = (byte) ((parts[3] >> 16) & 0x7F);
Decimal newValue = new Decimal(parts[0], parts[1], parts[2], sign, scale);
Console.WriteLine("{0} --> {1}", value, newValue);
}
}
}
// The example displays the following output:
// 1234.96 --> 1234.96
// -1234.96 --> -1234.96
open System
let values = [ 1234.96m; -1234.96m ]
for value in values do
let parts = Decimal.GetBits value
let sign = (parts[3] &&& 0x80000000) <> 0
let scale = (parts[3] >>> 16) &&& 0x7F |> byte
let newValue = Decimal(parts[0], parts[1], parts[2], sign, scale)
printfn $"{value} --> {newValue}"
// The example displays the following output:
// 1234.96 --> 1234.96
// -1234.96 --> -1234.96
Module Example
Public Sub Main()
Dim values() As Decimal = { 1234.96d, -1234.96d }
For Each value In values
Dim parts() = Decimal.GetBits(value)
Dim sign As Boolean = (parts(3) And &h80000000) <> 0
Dim scale As Byte = CByte((parts(3) >> 16) And &H7F)
Dim newValue As New Decimal(parts(0), parts(1), parts(2), sign, scale)
Console.WriteLine("{0} --> {1}", value, newValue)
Next
End Sub
End Module
' The example displays the following output:
' 1234.96 --> 1234.96
' -1234.96 --> -1234.96
Комментарии
Двоичное представление Decimal числа состоит из 1-битового знака, 96-битового целочисленного числа и коэффициента масштабирования, используемого для деления целочисленного числа и указания его части десятичной дроби. Коэффициент масштабирования неявно представляет собой число 10, возведенное в экспоненту в диапазоне от 0 до 28.
Возвращаемое значение представляет собой массив из четырех элементов из 32-разрядных целых чисел со знаком.
Первый, второй и третий элементы возвращаемого массива содержат низкий, средний и высокий 32 бита 96-разрядного целого числа.
Четвертый элемент возвращаемого массива содержит коэффициент масштабирования и знак. Он состоит из следующих частей:
Биты от 0 до 15 , нижнее слово, не используются и должны быть равны нулю.
Биты от 16 до 23 должны содержать экспоненту в диапазоне от 0 до 28, что указывает на степень 10 для деления целочисленного числа.
Биты от 24 до 30 не используются и должны быть равны нулю.
Бит 31 содержит знак: 0 означает положительный, а 1 означает отрицательный.
Обратите внимание, что битовое представление отличает отрицательное от положительного нуля. Эти значения считаются равными во всех операциях.
См. также раздел
Применяется к
GetBits(Decimal, Span<Int32>)
- Исходный код:
- Decimal.cs
- Исходный код:
- Decimal.cs
- Исходный код:
- Decimal.cs
Преобразует значение заданного экземпляра Decimal в эквивалентное ему двоичное представление.
public:
static int GetBits(System::Decimal d, Span<int> destination);public static int GetBits (decimal d, Span<int> destination);static member GetBits : decimal * Span<int> -> intPublic Shared Function GetBits (d As Decimal, destination As Span(Of Integer)) As IntegerПараметры
- d
- Decimal
Преобразуемое значение.
Возвращаемое значение
4— это количество целых чисел в двоичном представлении.
Исключения
Целевой диапазон имеет недостаточно большую длину для хранения двоичного представления.
Применяется к
Обратная связь
Ожидается в ближайшее время: в течение 2024 года мы постепенно откажемся от GitHub Issues как механизма обратной связи для контента и заменим его новой системой обратной связи. Дополнительные сведения см. в разделе https://aka.ms/ContentUserFeedback.
Отправить и просмотреть отзыв по