# 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 vão do 79.228.162.514.264.337.593.543.950.335 positivo ao 79.228.162.514.264.337.593.543.950.335 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 um `Decimal` é 0.The default value of a `Decimal` is 0. O Decimal tipo de valor é adequado para cálculos financeiros que exigem um grande número de dígitos integral e fracionário significativos e sem erros 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 nenhuma 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 escala que indica a posição de um ponto decimal flutuante que separa as partes integrais e fracionárias das 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 fator de escala usado para dividir o inteiro de 96 bits e especificar qual parte dele é uma fração decimal, um número inteiro de 96 bits e um 1 bit de sinal.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 escala é, implicitamente, o número 10, elevado a um expoente, variando 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 de formulário, ((-296 como 296) / 10(de 0 a 28)), onde-(296-1) é igual a MinValuee 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 do Decimal valores e exemplos, consulte a Decimal(Int32[]) construtor e o GetBits 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 qualquer à direita zeros 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, zeros à direita poderão ser revelados pelo ToString método se uma cadeia de caracteres de formato apropriado é 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 e para SByte, Int16, Int32, Int64, Byte, UInt16, UInt32, e UInt64 valores.This type provides methods that convert Decimal values to and from SByte, Int16, Int32, Int64, Byte, UInt16, UInt32, and UInt64 values. Conversões desses tipos integrais para Decimal são conversões de ampliação que nunca perder informações ou lançam exceções.Conversions from these integral types to Decimal are widening conversions that never lose information or throw exceptions.

Conversões de Decimal a qualquer um dos tipos integrais são de conversões de ida e volta de redução de 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. Algumas linguagens, como c#, também dão suporte a conversão de Decimal valores 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, um OverflowException exceção é 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 valores de e para Single e Double 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 de redução que poderá 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 lançará uma exceção.The conversion does not throw an exception.

Conversões de Single ou Double à Decimal lançar um OverflowException exceção se o resultado da conversão não pode ser representado como um Decimal.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 unário de negação.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érica padrão, ou você pode chamar o CompareTo ou Equals método.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 do Math classe para executar uma ampla variedade de operações numéricas, inclusive obter o valor absoluto de um número, determinando o valor máximo ou mínimo de dois Decimal valores, obter o sinal de um número e arredondamento 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).