# DecimalDecimalDecimalDecimal Struct

## Definição

Representa um número de ponto flutuante decimal.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``````
Herança
DecimalDecimalDecimalDecimal
Atributos
Implementações

## Exemplos

O exemplo de código a seguir demonstra o uso de 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
``````

## Comentários

O Decimal tipo de valor representa números decimais que variam de 79228162514264337593543950335 positivos a 79228162514264337593543950335 negativo.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. O valor padrão de a `Decimal` é 0.The default value of a `Decimal` is 0. O Decimal tipo de valor é apropriado para cálculos financeiros que exigem um grande número de dígitos inteiros e fracionários significativos e nenhum erro de arredondamento.The Decimal value type is appropriate for financial calculations that require large numbers of significant integral and fractional digits and no round-off errors. O Decimal tipo não elimina a necessidade de arredondamento.The Decimal type does not eliminate the need for rounding. Em vez disso, ele minimiza erros devido a arredondamento.Rather, it minimizes errors due to rounding. Por exemplo, o código a seguir produz um resultado de 0.9999999999999999999999999999 em vez de 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)
``````

Quando o resultado da divisão e multiplicação é passado para o Round método, o resultado não sofre perda de precisão, como mostra o código a seguir.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))
``````

Um número decimal é um valor de ponto flutuante que consiste em um sinal, um valor numérico em que cada dígito no valor varia de 0 a 9 e um fator de dimensionamento que indica a posição de um ponto decimal flutuante que separa as partes integral e fracionária do valor numérico.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.

A representação binária de um Decimal valor consiste em um sinal de 1 bit, um número inteiro de 96 bits e um fator de dimensionamento usado para dividir o inteiro de 96 bits e especificar qual parte dele é uma fração decimal.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. O fator de dimensionamento é implicitamente o número 10, elevado a um expoente que varia de 0 a 28.The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28. Portanto, a representação binária de um Decimal valor do formulário ((-296 a 296)/10(0 a 28)), onde-(296-1) é igual MinValuea e 296-1 é igual a 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. Para obter mais informações sobre a representação binária Decimal de valores e um exemplo, consulte Decimal(Int32[]) o construtor e GetBits o método.For more information about the binary representation of Decimal values and an example, see the Decimal(Int32[]) constructor and the GetBits method.

O fator de dimensionamento também preserva os zeros à direita em um Decimal número.The scaling factor also preserves any trailing zeros in a Decimal number. Zeros à direita não afetam o valor de um Decimal número em operações aritméticas ou de comparação.Trailing zeros do not affect the value of a Decimal number in arithmetic or comparison operations. No entanto, os ToString zeros à direita podem ser revelados pelo método se uma cadeia de caracteres de formato apropriada for aplicada.However, trailing zeros might be revealed by the ToString method if an appropriate format string is applied.

### Considerações de conversãoConversion Considerations

Esse tipo fornece métodos que convertem Decimal valores de Int64 SBytee para Int16valores Int32 Byte UInt64 ,, UInt16 UInt32,,,, e.This type provides methods that convert Decimal values to and from SByte, Int16, Int32, Int64, Byte, UInt16, UInt32, and UInt64 values. As conversões desses tipos Decimal integrais estão ampliando conversões que nunca perdem informações ou geram exceções.Conversions from these integral types to Decimal are widening conversions that never lose information or throw exceptions.

As conversões de Decimal para qualquer um dos tipos integrais estão restringindo conversões que arredondam o Decimal valor para o valor inteiro mais próximo em direção a zero.Conversions from Decimal to any of the integral types are narrowing conversions that round the Decimal value to the nearest integer value toward zero. Alguns idiomas, como C#, também oferecem suporte à conversão de Decimal valores em Char valores.Some languages, such as C#, also support the conversion of Decimal values to Char values. Se o resultado dessas conversões não puder ser representado no tipo de destino, uma OverflowException exceção será lançada.If the result of these conversions cannot be represented in the destination type, an OverflowException exception is thrown.

O Decimal tipo também fornece métodos que convertem Decimal Double valores de e Single para valores.The Decimal type also provides methods that convert Decimal values to and from Single and Double values. Conversões de Decimal Single ou Double são conversões estreitas que podem perder precisão, mas não informações sobre a magnitude do valor convertido.Conversions from Decimal to Single or Double are narrowing conversions that might lose precision but not information about the magnitude of the converted value. A conversão não gera uma exceção.The conversion does not throw an exception.

Single Conversões de Decimalou Double para Decimal gerar uma OverflowException exceção se o resultado da conversão não puder ser representado como um.Conversions from Single or Double to Decimal throw an OverflowException exception if the result of the conversion cannot be represented as a Decimal.

### Realizando operações em valores decimaisPerforming Operations on Decimal Values

O Decimal tipo dá suporte a operações matemáticas padrão, como adição, subtração, divisão, multiplicação e negação unário.The Decimal type supports standard mathematical operations such as addition, subtraction, division, multiplication, and unary negation. Você também pode trabalhar diretamente com a representação binária de um Decimal valor chamando o GetBits método.You can also work directly with the binary representation of a Decimal value by calling the GetBits method.

Para comparar dois Decimal valores, você pode usar os operadores de comparação numéricos padrão ou pode chamar o CompareTo método Equals ou.To compare two Decimal values, you can use the standard numeric comparison operators, or you can call the CompareTo or Equals method.

Você também pode chamar os membros da Math classe para executar uma ampla variedade de operações numéricas, incluindo obter o valor absoluto de um número, determinando o valor máximo ou mínimo de dois Decimal valores, obtendo o sinal de um número e arredondando um número.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.

## Construtores

 Decimal(Double) Decimal(Double) Decimal(Double) Decimal(Double) Inicializa uma nova instância de Decimal para o valor do número de ponto flutuante especificado de precisão dupla.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) Inicializa uma nova instância de Decimal para o valor inteiro com sinal de 32 bits especificado.Initializes a new instance of Decimal to the value of the specified 32-bit signed integer. Decimal(Int32[]) Decimal(Int32[]) Decimal(Int32[]) Decimal(Int32[]) Inicializa uma nova instância de Decimal para um valor decimal representado no binário e contido em uma matriz especificada.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) Inicializa uma nova instância de Decimal para o valor inteiro com sinal de 64 bits especificado.Initializes a new instance of Decimal to the value of the specified 64-bit signed integer. Decimal(Single) Decimal(Single) Decimal(Single) Decimal(Single) Inicializa uma nova instância de Decimal para o valor do número de ponto flutuante especificado de precisão simples.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) Inicializa uma nova instância de Decimal para o valor inteiro sem sinal de 32 bits especificado.Initializes a new instance of Decimal to the value of the specified 32-bit unsigned integer. Decimal(UInt64) Decimal(UInt64) Decimal(UInt64) Decimal(UInt64) Inicializa uma nova instância de Decimal para o valor inteiro sem sinal de 64 bits especificado.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) Inicializa uma nova instância de Decimal de parâmetros que especificam as partes constituintes da instância.Initializes a new instance of Decimal from parameters specifying the instance's constituent parts.

## Campos

 MaxValue MaxValue MaxValue MaxValue Representa o maior valor possível de Decimal.Represents the largest possible value of Decimal. Este campo é constante e somente leitura.This field is constant and read-only. MinusOne MinusOne MinusOne MinusOne Representa o número um negativo (-1).Represents the number negative one (-1). MinValue MinValue MinValue MinValue Representa o menor valor possível de Decimal.Represents the smallest possible value of Decimal. Este campo é constante e somente leitura.This field is constant and read-only. One One One One Representa o número um (1).Represents the number one (1). Zero Zero Zero Zero Representa o número zero (0).Represents the number zero (0).