C# Tipos e Limites

Cada tipo de número do C# ocupa um tamanho fixo na memória, e por isso tem um menor e um maior valor. Esta página junta, em tabelas, o tamanho e os limites de cada tipo, a precisão dos números com vírgula, o tipo de cada literal, o valor padrão e o que acontece quando uma conta passa do limite. Para aprender com calma, veja Tipos de Dados, Inteiros e float, double e decimal.

Todos os valores foram impressos de verdade pelos programas desta página, no dotnet 10.0.112 da máquina da Ana (pasta ~/cs/ref, cultura pt-BR, por isso a vírgula decimal) e conferidos no editor do guia. Quando os dois diferem, a página diz.

Atalhos: Tamanhos e limites · Precisão (float, double, decimal) · Valores especiais · Outros tipos · O tipo de cada literal · Valor padrão · Estouro e conversões · Quando dá errado · Experimente

Tamanhos e limites

Todo tipo numérico tem as constantes MinValue (o menor valor) e MaxValue (o maior). O sizeof diz quantos bytes ele ocupa. Este programa mostra todos:

// limites.cs — tamanho e limites de cada tipo numérico
Console.WriteLine($"{"Tipo",-8} {"Bytes",5}  {"Mínimo",28}  {"Máximo",28}");
Linha("sbyte", sizeof(sbyte), sbyte.MinValue, sbyte.MaxValue);
Linha("byte", sizeof(byte), byte.MinValue, byte.MaxValue);
Linha("short", sizeof(short), short.MinValue, short.MaxValue);
Linha("ushort", sizeof(ushort), ushort.MinValue, ushort.MaxValue);
Linha("int", sizeof(int), int.MinValue, int.MaxValue);
Linha("uint", sizeof(uint), uint.MinValue, uint.MaxValue);
Linha("long", sizeof(long), long.MinValue, long.MaxValue);
Linha("ulong", sizeof(ulong), ulong.MinValue, ulong.MaxValue);
Linha("char", sizeof(char), (int)char.MinValue, (int)char.MaxValue);
Linha("float", sizeof(float), float.MinValue, float.MaxValue);
Linha("double", sizeof(double), double.MinValue, double.MaxValue);
Linha("decimal", sizeof(decimal), decimal.MinValue, decimal.MaxValue);
Linha("bool", sizeof(bool), 0, 1);

static void Linha(string tipo, int bytes, object min, object max) =>
    Console.WriteLine($"{tipo,-8} {bytes,5}  {min,28}  {max,28}");

$ dotnet run limites.cs
Tipo     Bytes                        Mínimo                        Máximo
sbyte        1                          -128                           127
byte         1                             0                           255
short        2                        -32768                         32767
ushort       2                             0                         65535
int          4                   -2147483648                    2147483647
uint         4                             0                    4294967295
long         8          -9223372036854775808           9223372036854775807
ulong        8                             0          18446744073709551615
char         2                             0                         65535
float        4                -3,4028235E+38                 3,4028235E+38
double       8      -1,7976931348623157E+308       1,7976931348623157E+308
decimal     16  -79228162514264337593543950335  79228162514264337593543950335
bool         1                             0                             1

O E+38 é a notação científica: 3,4028235E+38 é 3,4 × 10³⁸, um número com 39 algarismos. O editor do guia mostra exatamente a mesma tabela.

• Os tamanhos são iguais em todo computador: no C#, int é sempre 32 bits, no Windows, no Linux, no celular e no editor do guia. (Em C, isso não é garantido.)
• Os tipos sem sinal (byte, ushort, uint, ulong) começam no 0 e vão até o dobro. O u é de "unsigned", "sem sinal". O único sem sinal comum é o byte; o sbyte ("signed byte") é o contrário.
• O sizeof funciona com estes tipos sem nada especial. Com outros (structs suas, nint), ele pede código unsafe (erro CS0233).

Precisão: float, double e decimal

Os três guardam números com vírgula, mas com precisão diferente. A conta 1 ÷ 3 mostra até onde cada um vai, e 0,1 + 0,2 mostra o erro de arredondamento do double:

// flutuante.cs — os valores especiais do float e do double
using System.Runtime.CompilerServices;

Console.WriteLine($"double.Epsilon = {double.Epsilon}");
Console.WriteLine($"float.Epsilon = {float.Epsilon}");
Console.WriteLine($"1.0 / 0 = {1.0 / 0}");
Console.WriteLine($"-1.0 / 0 = {-1.0 / 0}");
Console.WriteLine($"0.0 / 0 = {0.0 / 0}");
Console.WriteLine($"0.1 + 0.2 = {0.1 + 0.2}");
Console.WriteLine($"0.1f + 0.2f = {0.1f + 0.2f}");
Console.WriteLine($"0.1m + 0.2m = {0.1m + 0.2m}");
Console.WriteLine($"1.0 / 3 = {1.0 / 3}");
Console.WriteLine($"1.0f / 3 = {1.0f / 3}");
Console.WriteLine($"1.0m / 3 = {1.0m / 3}");
double nan = double.NaN;
Console.WriteLine($"NaN == NaN: {nan == double.NaN}");
Console.WriteLine($"double.IsNaN(0.0 / 0): {double.IsNaN(0.0 / 0)}");
Console.WriteLine($"Half: {Unsafe.SizeOf<Half>()} bytes, máximo {Half.MaxValue}");
Console.WriteLine($"Int128: {Unsafe.SizeOf<Int128>()} bytes");
Console.WriteLine($"Int128.MaxValue = {Int128.MaxValue}");
Console.WriteLine($"nint.Size = {nint.Size}");

$ dotnet run flutuante.cs
double.Epsilon = 5E-324
float.Epsilon = 1E-45
1.0 / 0 = ∞
-1.0 / 0 = -∞
0.0 / 0 = NaN
0.1 + 0.2 = 0,30000000000000004
0.1f + 0.2f = 0,3
0.1m + 0.2m = 0,3
1.0 / 3 = 0,3333333333333333
1.0f / 3 = 0,33333334
1.0m / 3 = 0,3333333333333333333333333333
NaN == NaN: False
double.IsNaN(0.0 / 0): True
Half: 2 bytes, máximo 65500
Int128: 16 bytes
Int128.MaxValue = 170141183460469231731687303715884105727
nint.Size = 8

Por que o double erra em 0,1 + 0,2? Ele guarda os números em base 2, e 0,1 em base 2 é uma dízima infinita (como 1/3 em base 10). O decimal guarda em base 10, por isso 0,1 é exato. É a razão de o guia usar decimal para dinheiro, sempre. Aula: float, double e decimal.

Valores especiais do float e do double

Com inteiros é diferente: 7 / 0 com uma variável lança DivideByZeroException, e com constantes nem compila (veja Exceções e Erros do Compilador).

Outros tipos numéricos

O tipo de cada literal

Um número escrito no código (um literal) já tem tipo. O GetType().Name mostra qual:

// nomes.cs — o nome .NET de cada apelido, e o tipo de cada literal
Console.WriteLine($"{typeof(int).FullName} {typeof(string).FullName} {typeof(bool).FullName} {typeof(decimal).FullName}");
object[] literais = [5, 5L, 5u, 5ul, 3_000_000_000, 5.0, 5f, 5m, 5e3, 'a', "a", true, 0x1F, 0b1010];
string[] textos = ["5", "5L", "5u", "5ul", "3_000_000_000", "5.0", "5f", "5m", "5e3", "'a'", "\"a\"", "true", "0x1F", "0b1010"];
for (int i = 0; i < literais.Length; i++)
{
    Console.WriteLine($"{textos[i],-14} {literais[i].GetType().Name,-8} {literais[i]}");
}

$ dotnet run nomes.cs
System.Int32 System.String System.Boolean System.Decimal
5              Int32    5
5L             Int64    5
5u             UInt32   5
5ul            UInt64   5
3_000_000_000  UInt32   3000000000
5.0            Double   5
5f             Single   5
5m             Decimal  5
5e3            Double   5000
'a'            Char     a
"a"            String   a
true           Boolean  True
0x1F           Int32    31
0b1010         Int32    10

Valor padrão (default)

Campos de uma classe, itens de um array novo e default(T) começam com o valor padrão do tipo. (Variáveis locais, não: o compilador exige que você dê um valor antes de usar.)

// padroes.cs — valor padrão (default) de cada tipo
Console.WriteLine($"int: [{default(int)}]");
Console.WriteLine($"double: [{default(double)}]");
Console.WriteLine($"decimal: [{default(decimal)}]");
Console.WriteLine($"bool: [{default(bool)}]");
Console.WriteLine($"char: [{(int)default(char)}] (o caractere de código 0)");
Console.WriteLine($"string: [{default(string) ?? "null"}]");
Console.WriteLine($"int?: [{(default(int?) is null ? "null" : "?")}]");
Console.WriteLine($"DateTime: [{default(DateTime)}]");

$ dotnet run padroes.cs
int: [0]
double: [0]
decimal: [0]
bool: [False]
char: [0] (o caractere de código 0)
string: [null]
int?: [null]
DateTime: [01/01/0001 00:00:00]

Estouro e conversões

O que acontece quando o valor não cabe no tipo, ou quando um double vira int:

// estouro.cs — o que acontece quando passa do limite
int maior = int.MaxValue;
Console.WriteLine($"int.MaxValue + 1 = {maior + 1}");
byte b = 255;
b++;
Console.WriteLine($"byte 255 + 1 = {b}");
Console.WriteLine($"(int)3.99 = {(int)3.99}");
Console.WriteLine($"(int)-3.99 = {(int)-3.99}");
double grande = 1e20, nada = double.NaN;
Console.WriteLine($"(int)1e20 = {(int)grande}");
Console.WriteLine($"(int)NaN = {(int)nada}");
int trezentos = 300;
Console.WriteLine($"(byte)300 = {(byte)trezentos}");
Console.WriteLine($"Math.Round(2.5) = {Math.Round(2.5)}, Math.Round(3.5) = {Math.Round(3.5)}");
Console.WriteLine($"Convert.ToInt32(2.5) = {Convert.ToInt32(2.5)}, Convert.ToInt32(3.5) = {Convert.ToInt32(3.5)}");
Console.WriteLine($"7 / 2 = {7 / 2}, 7 % 2 = {7 % 2}, -7 / 2 = {-7 / 2}, -7 % 2 = {-7 % 2}");
Console.WriteLine(checked(maior + 1));

$ dotnet run estouro.cs
int.MaxValue + 1 = -2147483648
byte 255 + 1 = 0
(int)3.99 = 3
(int)-3.99 = -3
(int)1e20 = 2147483647
(int)NaN = 0
(byte)300 = 44
Math.Round(2.5) = 2, Math.Round(3.5) = 4
Convert.ToInt32(2.5) = 2, Convert.ToInt32(3.5) = 4
7 / 2 = 3, 7 % 2 = 1, -7 / 2 = -3, -7 % 2 = -1
Unhandled exception. System.OverflowException: Arithmetic operation resulted in an overflow.
   at Program.<Main>$(String[] args) in /home/ana/cs/ref/estouro.cs:line 17
$ echo $?
134

Conversões que acontecem sozinhas (implícitas)

O C# converte sozinho quando não há risco de perder informação. Quando há, ele exige o cast (tipo):

Repare: int → float é implícito mas pode perder algarismos (o float só tem uns 7). E double e decimal nunca viram um no outro sozinhos. Aula: Conversão de Tipos.

Quando dá errado

// A população de três países, somada
int brasil = 213_000_000;
int india = 1_450_000_000;
int china = 1_410_000_000;
int soma = brasil + india + china;
Console.WriteLine($"Soma: {soma}");

$ dotnet run populacao.cs
Soma: -1221967296

Experimente

// A população de três países, somada
int brasil = 213_000_000;
int india = 1_450_000_000;
int china = 1_410_000_000;
int soma = brasil + india + china;
Console.WriteLine($"Soma: {soma}");

// A população de três países, somada
long brasil = 213_000_000;
long india = 1_450_000_000;
long china = 1_410_000_000;
long soma = brasil + india + china;
Console.WriteLine($"Soma: {soma}");

Console.WriteLine($"short vai de {short.MinValue} a {short.MaxValue}");
Console.WriteLine(short.MaxValue + 1);
Console.WriteLine(1.0 / 3);
Console.WriteLine(1.0m / 3);
Console.WriteLine(0.1 + 0.2 == 0.3);
Console.WriteLine(0.1m + 0.2m == 0.3m);

Resumo

• Os tamanhos são fixos: byte 1, short 2, int 4, long 8, float 4, double 8, decimal 16, char 2 bytes. Só o nint muda (8 no lab, 4 no editor).
• int vai até 2 147 483 647; para mais, long. Para dinheiro, decimal; para medidas, double.
• Sufixos: L (long), u, ul, f (float), m (decimal). Sem sufixo, inteiro é int e número com ponto é double.
• Inteiro que passa do limite dá a volta sem aviso; com checked, lança OverflowException.
• O cast (int) corta a parte decimal; Math.Round e Convert.ToInt32 arredondam para o par.
• double dividido por zero dá ∞ ou NaN; NaN se testa com double.IsNaN.