# Decimal Struktura

## 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
Decimal
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 hodnoty Decimal 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. Typ Decimal 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)
``````

Když je výsledek dělení a násobení předán metodě Round, 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 dělení 96 celého čísla a určení, která část je desítkovou desetinnou čárkou.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-(296-1) se rovná MinValuea 296-1 je rovna 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í reprezentaci Decimal hodnoty a příkladu naleznete v konstruktoru Decimal(Int32[]) a v metodě GetBits.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 Decimalm čísle.The scaling factor also preserves any trailing zeros in a Decimal number. Koncové nuly neovlivňují hodnotu Decimal číslo 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 odhalena metodou ToString, 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é převádějí Decimal hodnoty do a z SByte, Int16, Int32, Int64, Byte, UInt16, UInt32a UInt64 hodnoty.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ů na Decimal 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é zaokrouhlují hodnotu Decimal 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 hodnot Decimal na Char hodnot.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, je vyvolána výjimka OverflowException.If the result of these conversions cannot be represented in the destination type, an OverflowException exception is thrown.

Typ Decimal také poskytuje metody, které převádějí Decimal hodnoty do a z Single a Double hodnoty.The 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řevod z Single nebo Double na Decimal vyvolá výjimku OverflowException, pokud výsledek převodu nemůže být reprezentován jako Decimal.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

Typ Decimal 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 hodnoty Decimal voláním metody GetBits.You can also work directly with the binary representation of a Decimal value by calling the GetBits method.

Chcete-li porovnat dvě Decimal hodnoty, můžete použít standardní číselné operátory porovnání nebo můžete zavolat metodu CompareTo 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 třídy Math k 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í čísla.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

 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. Inicializuje novou instanci Decimal k hodnotě 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. Inicializuje novou instanci Decimal z parametrů, které určují prvky části instance.Initializes a new instance of Decimal from parameters specifying the instance's constituent parts. 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. Inicializuje novou instanci Decimal k hodnotě 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. 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. Inicializuje novou instanci Decimal na hodnotu zadaného unsigned integer bitů na 32.Initializes a new instance of Decimal to the value of the specified 32-bit unsigned integer. Inicializuje novou instanci Decimal na hodnotu zadaného unsigned integer bitů na 64.Initializes a new instance of Decimal to the value of the specified 64-bit unsigned integer.

## Pole

 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. Představuje číslo záporného typu (-1).Represents the number negative one (-1). 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. Představuje číslo 1 (1).Represents the number one (1). Představuje číslo nula (0).Represents the number zero (0).