Tipos de dados em C#: int, double, decimal, char, bool e seus intervalos

C# tem tipagem estática: toda variável, campo e expressão tem um tipo conhecido em tempo de compilação. A linguagem tem um conjunto de tipos embutidos com palavras-chave próprias (int, double, string...). Cada palavra-chave é um apelido para um tipo do namespace System, então int e System.Int32 são o mesmo tipo, e string e System.String são o mesmo tipo.

Os tipos embutidos

Um literal inteiro sem sufixo é um int, ou o primeiro entre uint, long e ulong que consiga guardá-lo se for grande demais para um int, e um literal com ponto decimal é um double. É por isso que float f = 2.5; e decimal d = 2.5; não compilam: o literal é um double, e não existe conversão implícita de double para float ou decimal. Adicione o sufixo: 2.5f, 2.5m.

Todo tipo numérico expõe seus limites como constantes:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"byte:  {byte.MinValue} to {byte.MaxValue}");
        Console.WriteLine($"short: {short.MinValue} to {short.MaxValue}");
        Console.WriteLine($"int:   {int.MinValue} to {int.MaxValue}");
        Console.WriteLine($"long:  {long.MinValue} to {long.MaxValue}");
        Console.WriteLine($"decimal max: {decimal.MaxValue}");
        Console.WriteLine($"double max:  {double.MaxValue:E3}");
        Console.WriteLine($"sizes: int {sizeof(int)}, long {sizeof(long)}, double {sizeof(double)}, char {sizeof(char)}");

        int hex = 0xFF;             // hexadecimal
        int bits = 0b1010_0001;     // binary (C# 7)
        long big = 3_000_000_000;   // digit separators (C# 7)
        Console.WriteLine($"{hex} {bits} {big}");
    }
}

Saída:

byte:  0 to 255
short: -32768 to 32767
int:   -2147483648 to 2147483647
long:  -9223372036854775808 to 9223372036854775807
decimal max: 79228162514264337593543950335
double max:  1.798E+308
sizes: int 4, long 8, double 8, char 2
255 161 3000000000

Na prática, a maior parte do código usa quatro desses: int para contagens e índices, long para IDs e totais grandes, double para medições e matemática, e decimal para dinheiro.

decimal vs double

double (e float) guardam números em binário. A maioria das frações decimais, incluindo 0.1, não tem forma binária exata, então elas são guardadas como o valor representável mais próximo e pequenos erros se acumulam. decimal guarda um inteiro na base 10 mais uma escala, então 0.1 é exatamente 0.1.

using System;

class Program
{
    static void Main()
    {
        double a = 0.1 + 0.2;
        decimal b = 0.1m + 0.2m;
        Console.WriteLine(a == 0.3);          // False
        Console.WriteLine(b == 0.3m);         // True
        Console.WriteLine(a.ToString("G17")); // 17 significant digits
        Console.WriteLine(b);

        double dsum = 0;
        decimal msum = 0;
        for (int i = 0; i < 10; i++)
        {
            dsum += 0.1;
            msum += 0.1m;
        }
        Console.WriteLine($"double sum == 1.0: {dsum == 1.0}");
        Console.WriteLine($"decimal sum == 1.0: {msum == 1.0m}");

        decimal price = 19.99m;
        int quantity = 3;
        decimal total = price * quantity;
        Console.WriteLine($"Total: {total}");
        Console.WriteLine($"Split three ways: {total / 3}");
    }
}

Saída:

False
True
0.30000000000000004
0.3
double sum == 1.0: False
decimal sum == 1.0: True
Total: 59.97
Split three ways: 19.99

Use decimal para dinheiro, preços, impostos e qualquer coisa que uma pessoa vá somar à mão e comparar. Ele mantém os zeros à direita das entradas (1.50m é impresso como 1.50) e tem de 28 a 29 dígitos significativos.

Use double para medições físicas, estatística, geometria e jogos. Ele é várias vezes mais rápido, usa metade da memória e tem um intervalo enorme. Nunca compare dois doubles calculados com ==; compare a diferença com uma tolerância: Math.Abs(x - y) < 1e-9.

decimal não é mágico: 1m / 3m continua sendo 0.3333333333333333333333333333, e a aritmética com double não lança exceção na divisão por zero (produz infinito, ou NaN para 0.0 / 0.0), enquanto a divisão por zero de decimal e de inteiros lança uma DivideByZeroException.

Overflow de inteiros e checked

Aritmética inteira que passa do intervalo do tipo dá a volta por padrão, sem aviso. O compilador pega o overflow em expressões constantes, mas não quando os valores vêm de variáveis:

using System;

class Program
{
    static void Main()
    {
        int max = int.MaxValue;
        int wrapped = max + 1;           // no error: wraps around
        Console.WriteLine(wrapped);

        try
        {
            int safe = checked(max + 1); // throws instead of wrapping
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("OverflowException");
        }

        long views = 3_000_000_000;
        int truncated = unchecked((int)views); // explicit narrowing keeps low 32 bits
        Console.WriteLine(truncated);

        long total = (long)max + 1;       // widen first to get the right answer
        Console.WriteLine(total);
    }
}

Saída:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) ou um bloco checked { ... } transforma o overflow em uma OverflowException. Você também pode ativar isso para o projeto inteiro com <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. Escrever int x = int.MaxValue + 1; com constantes é um erro de compilação (CS0220), porque o compilador consegue ver o overflow.

A última linha mostra a solução para a maioria dos bugs de overflow: converter para um tipo maior antes da aritmética. (long)(max + 1) estaria errado, já que a soma já deu a volta quando o cast executa.

Tipos de valor e tipos de referência

Todo tipo em C# é um tipo de valor ou um tipo de referência, e a diferença decide o que a atribuição faz.

• Tipos de valor: todos os tipos numéricos, bool, char, DateTime, enums e toda struct. A variável contém os dados; a atribuição os copia.
• Tipos de referência: string, arrays, object e toda class. A variável contém uma referência para um objeto; a atribuição copia a referência, então as duas variáveis veem o mesmo objeto.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        int b = a;      // copy of the value
        b = 99;
        Console.WriteLine($"a={a} b={b}");

        int[] first = { 1, 2, 3 };
        int[] second = first;   // copy of the reference
        second[0] = 99;
        Console.WriteLine($"first[0]={first[0]}");

        string s1 = "cat";
        string s2 = s1;
        s2 += "s";              // strings are immutable: s2 now refers to a new string
        Console.WriteLine($"s1={s1} s2={s2}");
    }
}

Saída:

a=10 b=99
first[0]=99
s1=cat s2=cats

string é um tipo de referência que, na prática, se comporta como um valor: ela é imutável, e == compara o texto, não as referências. Mais sobre tipos de valor definidos pelo usuário em structs.

char e bool

Um char é uma unidade de código UTF-16, escrita entre aspas simples. Por baixo, é um tipo numérico, então se converte para int e aceita aritmética:

using System;

class Program
{
    static void Main()
    {
        char grade = 'B';
        Console.WriteLine((int)grade);           // 66
        Console.WriteLine((char)(grade + 1));    // C
        Console.WriteLine(char.IsLetter(grade));
        Console.WriteLine(char.IsDigit('7'));
        Console.WriteLine('7' - '0');             // digit char to its value
        Console.WriteLine(char.ToLower(grade));

        bool isOpen = true;
        bool hasStock = false;
        Console.WriteLine(isOpen && !hasStock);
    }
}

Saída:

66
C
True
True
7
b
True

bool tem exatamente dois valores e não se converte de ou para números: if (count) é um erro de compilação, não um teste de diferente de zero. Escreva if (count != 0). Caracteres fora do Plano Multilíngue Básico, como a maioria dos emojis, ocupam dois valores char (um par substituto), então o Length de uma string conta unidades UTF-16, não caracteres visíveis.

Valores padrão

Campos, elementos de array e default(T) recebem o valor padrão do tipo: zero para números, false para bool, '\0' para char e null para tipos de referência. Variáveis locais não recebem padrão e precisam ser atribuídas antes do uso.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(default(int));
        Console.WriteLine(default(decimal));
        Console.WriteLine(default(bool));
        Console.WriteLine(default(string) == null);
        Console.WriteLine(default(DateTime).ToString("yyyy-MM-dd"));

        var counts = new int[3];
        Console.WriteLine(string.Join(",", counts));
    }
}

Saída:

0
0
False
True
0001-01-01
0,0,0

Desde o C# 7.1, você pode escrever o literal default sem o tipo quando o compilador consegue inferi-lo (int x = default;). Um tipo de valor não pode ser null, e é para isso que existe int? (um tipo de valor anulável); veja tipos anuláveis.

Inteiros do tamanho nativo e inteiros grandes

Mais dois tipos numéricos existem para casos especiais. nint e nuint (C# 9) são inteiros do tamanho de um ponteiro, 32 ou 64 bits conforme a plataforma, usados em interoperabilidade e código de baixo nível. System.Numerics.BigInteger guarda inteiros de qualquer tamanho, ao custo de velocidade:

using System.Numerics;
BigInteger factorial = 1;
for (int i = 2; i <= 30; i++) factorial *= i;
// 265252859812191058636308480000000