DecimalDecimalDecimalDecimal Struct

Definice

Představuje desetinné číslo s plovoucí desetinnou čárkou.Represents a decimal floating-point number.

``public value class Decimal : IComparable, IComparable<System::Decimal>, IConvertible, IEquatable<System::Decimal>, IFormattable, System::Runtime::Serialization::IDeserializationCallback``
``````[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Decimal : IComparable, IComparable<decimal>, IConvertible, IEquatable<decimal>, IFormattable, System.Runtime.Serialization.IDeserializationCallback``````
``````type decimal = struct
interface IFormattable
interface IConvertible
interface IDeserializationCallback``````
``````Public Structure Decimal
Implements IComparable, IComparable(Of Decimal), IConvertible, IDeserializationCallback, IEquatable(Of Decimal), IFormattable``````
Dědičnost
DecimalDecimalDecimalDecimal
Atributy
Implementuje

Následující příklad kódu ukazuje použití Decimal.The following code example demonstrates the use of Decimal.

``````   /// <summary>
/// Keeping my fortune in Decimals to avoid the round-off errors.
/// </summary>
public ref class PiggyBank
{
protected:
Decimal MyFortune;

public:
{
MyFortune = System::Decimal::Add( MyFortune, Decimal(.01) );
}

System::Decimal Capacity()
{
return MyFortune.MaxValue;
}

Decimal Dollars()
{
return Decimal::Floor( MyFortune );
}

Decimal Cents()
{
return Decimal::Subtract( MyFortune, Decimal::Floor( MyFortune ) );
}

virtual System::String^ ToString() override
{
return MyFortune.ToString("C")+" in piggy bank";
}
};
}
``````
``````/// <summary>
/// Keeping my fortune in Decimals to avoid the round-off errors.
/// </summary>
class PiggyBank {
protected decimal MyFortune;

}

public decimal Capacity {
get {
return Decimal.MaxValue;
}
}

public decimal Dollars {
get {
return Decimal.Floor(MyFortune);
}
}

public decimal Cents {
get {
return Decimal.Subtract(MyFortune, Decimal.Floor(MyFortune));
}
}

public override string ToString() {
return MyFortune.ToString("C")+" in piggy bank";
}
}
``````
``````' Keeping my fortune in Decimals to avoid the round-off errors.
Class PiggyBank
Protected MyFortune As Decimal

End Sub

Public ReadOnly Property Capacity() As Decimal
Get
Return [Decimal].MaxValue
End Get
End Property

Public ReadOnly Property Dollars() As Decimal
Get
Return [Decimal].Floor(MyFortune)
End Get
End Property

Public ReadOnly Property Cents() As Decimal
Get
Return [Decimal].Subtract(MyFortune, [Decimal].Floor(MyFortune))
End Get
End Property

Public Overrides Function ToString() As String
Return MyFortune.ToString("C") + " in piggy bank"
End Function
End Class
``````

Poznámky

Typ Decimal hodnoty představuje desítková čísla od kladného 79,228,162,514,264,337,593,543,950,335 do záporného 79,228,162,514,264,337,593,543,950,335.The Decimal value type represents decimal numbers ranging from positive 79,228,162,514,264,337,593,543,950,335 to negative 79,228,162,514,264,337,593,543,950,335. Výchozí hodnota `Decimal` je 0.The default value of a `Decimal` is 0. Typ Decimal hodnoty je vhodný pro finanční výpočty, které vyžadují velký počet významných integrálních a zlomkových číslic a žádné chyby zaokrouhlení.The Decimal value type is appropriate for financial calculations that require large numbers of significant integral and fractional digits and no round-off errors. Decimal Typ neeliminuje nutnost zaokrouhlování.The Decimal type does not eliminate the need for rounding. Místo toho minimalizuje chyby z důvodu zaokrouhlení.Rather, it minimizes errors due to rounding. Například následující kód vytvoří výsledek 0.9999999999999999999999999999 místo 1.For example, the following code produces a result of 0.9999999999999999999999999999 instead of 1.

``````using namespace System;

void main()
{
Decimal dividend = Decimal::One;
Decimal divisor = 3;
// The following displays 0.9999999999999999999999999999 to the console
Console::WriteLine(dividend/divisor * divisor);
}
``````
``````decimal dividend = Decimal.One;
decimal divisor = 3;
// The following displays 0.9999999999999999999999999999 to the console
Console.WriteLine(dividend/divisor * divisor);
``````
``````Dim dividend As Decimal = Decimal.One
Dim divisor As Decimal = 3
' The following displays 0.9999999999999999999999999999 to the console
Console.WriteLine(dividend/divisor * divisor)
``````

V případě, že je výsledek dělení a násobení předán Round metodě, výsledek nevede ke ztrátě přesnosti, jak ukazuje následující kód.When the result of the division and multiplication is passed to the Round method, the result suffers no loss of precision, as the following code shows.

``````using namespace System;

void main()
{
Decimal dividend = Decimal::One;
Decimal divisor = 3;
// The following displays 1.00 to the console
Console::WriteLine(Math::Round(dividend/divisor * divisor, 2));
}
``````
``````decimal dividend = Decimal.One;
decimal divisor = 3;
// The following displays 1.00 to the console
Console.WriteLine(Math.Round(dividend/divisor * divisor, 2));
``````
``````Dim dividend As Decimal = Decimal.One
Dim divisor As Decimal = 3
' The following displays 1.00 to the console
Console.WriteLine(Math.Round(dividend/divisor * divisor, 2))
``````

Desítkové číslo je hodnota s plovoucí desetinnou čárkou, která se skládá z znaku, číselná hodnota, kde každá číslice v rozsahu hodnot je 0 až 9, a faktor měřítka, který označuje pozici plovoucí desetinné čárky, která odděluje celočíselnou a zlomkovou část. Číselná hodnota.A decimal number is a floating-point value that consists of a sign, a numeric value where each digit in the value ranges from 0 to 9, and a scaling factor that indicates the position of a floating decimal point that separates the integral and fractional parts of the numeric value.

Binární reprezentace Decimal hodnoty se skládá z navážky znaménka, 96 celočíselného čísla a faktor škálování, který se používá k rozdělení 96 celého čísla a určení, která část je desítkovým zlomkem.The binary representation of a Decimal value consists of a 1-bit sign, a 96-bit integer number, and a scaling factor used to divide the 96-bit integer and specify what portion of it is a decimal fraction. Faktor škálování je implicitně číslo 10, které se vyvolalo na exponent v rozsahu od 0 do 28.The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28. Proto binární reprezentace Decimal hodnoty formuláře ((-296 až 296)/10(0 až 28)), kde-( MinValue296-1) se rovná a 296-1 je rovno MaxValue.Therefore, the binary representation of a Decimal value the form, ((-296 to 296) / 10(0 to 28)), where -(296-1) is equal to MinValue, and 296-1 is equal to MaxValue. Další informace o binární reprezentace Decimal hodnot a příklad Decimal(Int32[]) naleznete v konstruktoru a v GetBits metodě.For more information about the binary representation of Decimal values and an example, see the Decimal(Int32[]) constructor and the GetBits method.

Faktor škálování také zachovává všechny koncové nuly v Decimal čísle.The scaling factor also preserves any trailing zeros in a Decimal number. Koncové nuly neovlivňují hodnotu Decimal čísla v aritmetických nebo relačních operacích.Trailing zeros do not affect the value of a Decimal number in arithmetic or comparison operations. Koncová nula však může být ToString metoda odhalena metodou, pokud je použit příslušný řetězec formátu.However, trailing zeros might be revealed by the ToString method if an appropriate format string is applied.

Hlediska převodůConversion Considerations

Tento typ poskytuje metody, které Decimal převádějí hodnoty na SBytehodnoty Int16a Int32 Int64,, Byte, UInt16, UInt32,, UInt64 a.This type provides methods that convert Decimal values to and from SByte, Int16, Int32, Int64, Byte, UInt16, UInt32, and UInt64 values. Převody z těchto integrálních typů Decimal na jsou rozšiřující převody, které nikdy neztrácejí informace nebo vyvolávají výjimky.Conversions from these integral types to Decimal are widening conversions that never lose information or throw exceptions.

Převody z Decimal na jakýkoli celočíselný typ jsou zužující převody, které Decimal zaokrouhlují hodnotu na nejbližší celočíselnou hodnotu směrem nula.Conversions from Decimal to any of the integral types are narrowing conversions that round the Decimal value to the nearest integer value toward zero. Některé jazyky, například C#, podporují také převod Decimal hodnot na Char hodnoty.Some languages, such as C#, also support the conversion of Decimal values to Char values. Pokud výsledek těchto převodů nelze reprezentovat v cílovém typu, OverflowException je vyvolána výjimka.If the result of these conversions cannot be represented in the destination type, an OverflowException exception is thrown.

Typ také poskytuje metody, které převádějí Decimal hodnoty na a Single z Double a hodnoty. DecimalThe Decimal type also provides methods that convert Decimal values to and from Single and Double values. Převody z Decimal na Single nebo Double jsou zužující převody, které by mohly přijít o přesnost, ale ne informace o velikosti převedené hodnoty.Conversions from Decimal to Single or Double are narrowing conversions that might lose precision but not information about the magnitude of the converted value. Převod nevyvolá výjimku.The conversion does not throw an exception.

Převody z Single nebo Double k Decimal vyvolání výjimkyOverflowException , PokudvýsledekpřevodunemůžebýtDecimalreprezentovaný jako.Conversions from Single or Double to Decimal throw an OverflowException exception if the result of the conversion cannot be represented as a Decimal.

Provádění operací na desetinných hodnotáchPerforming Operations on Decimal Values

Decimal Typ podporuje standardní matematické operace, jako například sčítání, odčítání, dělení, násobení a unární negaci.The Decimal type supports standard mathematical operations such as addition, subtraction, division, multiplication, and unary negation. Můžete také pracovat přímo s binárním znázorněním Decimal hodnoty GetBits voláním metody.You can also work directly with the binary representation of a Decimal value by calling the GetBits method.

Pro porovnání dvou Decimal hodnot můžete použít standardní číselné operátory porovnání nebo můžete CompareTo zavolat metodu nebo Equals .To compare two Decimal values, you can use the standard numeric comparison operators, or you can call the CompareTo or Equals method.

Můžete také volat členy Math třídy pro provedení široké škály číselných operací, včetně získání absolutní hodnoty čísla, určení maximální nebo minimální hodnoty dvou Decimal hodnot, získání znaménka čísla a zaokrouhlení číslo.You can also call the members of the Math class to perform a wide range of numeric operations, including getting the absolute value of a number, determining the maximum or minimum value of two Decimal values, getting the sign of a number, and rounding a number.

Konstruktory

 Decimal(Double) Decimal(Double) Decimal(Double) Decimal(Double) Inicializuje novou instanci Decimal na hodnotu zadaného čísla s plovoucí desetinnou čárkou a dvojitou přesností.Initializes a new instance of Decimal to the value of the specified double-precision floating-point number. Decimal(Int32) Decimal(Int32) Decimal(Int32) Decimal(Int32) Inicializuje novou instanci Decimal na hodnotu zadaného celého čísla se znaménkem 32.Initializes a new instance of Decimal to the value of the specified 32-bit signed integer. Decimal(Int32[]) Decimal(Int32[]) Decimal(Int32[]) Decimal(Int32[]) Inicializuje novou instanci Decimal na desítkovou hodnotu reprezentovanou v binárním souboru a obsaženou v zadaném poli.Initializes a new instance of Decimal to a decimal value represented in binary and contained in a specified array. Decimal(Int64) Decimal(Int64) Decimal(Int64) Decimal(Int64) Inicializuje novou instanci Decimal na hodnotu zadaného celého čísla se znaménkem 64.Initializes a new instance of Decimal to the value of the specified 64-bit signed integer. Decimal(Single) Decimal(Single) Decimal(Single) Decimal(Single) Inicializuje novou instanci Decimal na hodnotu zadaného čísla s plovoucí desetinnou čárkou s jednoduchou přesností.Initializes a new instance of Decimal to the value of the specified single-precision floating-point number. Decimal(UInt32) Decimal(UInt32) Decimal(UInt32) Decimal(UInt32) Inicializuje novou instanci Decimal na hodnotu zadaného 32-bit unsigned integer.Initializes a new instance of Decimal to the value of the specified 32-bit unsigned integer. Decimal(UInt64) Decimal(UInt64) Decimal(UInt64) Decimal(UInt64) Inicializuje novou instanci Decimal na hodnotu zadaného 64-bit unsigned integer.Initializes a new instance of Decimal to the value of the specified 64-bit unsigned integer. Decimal(Int32, Int32, Int32, Boolean, Byte) Decimal(Int32, Int32, Int32, Boolean, Byte) Decimal(Int32, Int32, Int32, Boolean, Byte) Decimal(Int32, Int32, Int32, Boolean, Byte) Inicializuje novou instanci z parametrů Decimal , které určují prvky části instance.Initializes a new instance of Decimal from parameters specifying the instance's constituent parts.

Pole

 MaxValue MaxValue MaxValue MaxValue Představuje největší možnou hodnotu Decimal.Represents the largest possible value of Decimal. Toto pole je konstantní a jen pro čtení.This field is constant and read-only. MinusOne MinusOne MinusOne MinusOne Představuje číslo záporného typu (-1).Represents the number negative one (-1). MinValue MinValue MinValue MinValue Představuje nejmenší možnou hodnotu Decimal.Represents the smallest possible value of Decimal. Toto pole je konstantní a jen pro čtení.This field is constant and read-only. One One One One Představuje číslo 1 (1).Represents the number one (1). Zero Zero Zero Zero Představuje číslo nula (0).Represents the number zero (0).