Compartilhar via

operador sizeof – determinar as necessidades de memória para um determinado tipo

O operador sizeof retorna o número de bytes ocupados por uma variável de um determinado tipo. No código seguro, o argumento para o sizeof operador deve ser o nome de um tipo não gerenciado interno cujo tamanho não depende da plataforma.

A linguagem C# faz referência a documentos da versão mais recentemente lançada da linguagem C#. Ele também contém a documentação inicial para funcionalidades em pré-visualizações públicas para o próximo lançamento do idioma.

A documentação identifica qualquer recurso introduzido pela primeira vez nas três últimas versões do idioma ou nas versões prévias públicas atuais.

Dica

Para descobrir quando um recurso foi introduzido pela primeira vez em C#, consulte o artigo sobre o histórico de versão da linguagem C#.

As expressões apresentadas na tabela a seguir são avaliadas em tempo de compilação para os valores constantes correspondentes e não exigem um contexto não seguro:

Expression Valor constante
sizeof(sbyte) 1
sizeof(byte) 1
sizeof(short) 2
sizeof(ushort) 2
sizeof(int) 4
sizeof(uint) 4
sizeof(long) 8
sizeof(ulong) 8
sizeof(char) 2
sizeof(float) 4
sizeof(double) 8
sizeof(decimal) 16
sizeof(bool) 1

O tamanho dos tipos na tabela anterior é uma constante de tempo de compilação.

No código não seguro , você pode usar sizeof em qualquer tipo diferentevoid , incluindo tipos construídos a partir de parâmetros de tipo.

  • O tamanho de uma referência ou tipo de ponteiro é o tamanho de uma referência ou ponteiro, não o tamanho do objeto ao qual ele pode se referir.
  • O tamanho de um tipo de valor, não gerenciado ou não, é do tamanho desse valor.
  • O tamanho de um ref struct tipo é o tamanho do valor. O tamanho de cada ref campo é o tamanho de uma referência ou ponteiro, não o tamanho do valor ao qual se refere.

O exemplo a seguir demonstra o uso do operador sizeof:

public struct Point
{
    public Point(byte tag, double x, double y) => (Tag, X, Y) = (tag, x, y);

    public byte Tag { get; }
    public double X { get; }
    public double Y { get; }
}

public class SizeOfOperator
{
    public static void Main()
    {
        Console.WriteLine(sizeof(byte));  // output: 1
        Console.WriteLine(sizeof(double));  // output: 8

        DisplaySizeOf<Point>();  // output: Size of Point is 24
        DisplaySizeOf<decimal>();  // output: Size of System.Decimal is 16

        unsafe
        {
            Console.WriteLine(sizeof(Point*));  // output: 8
            Console.WriteLine(sizeof(nint));  // output: 8 on 64-bit, 4 on 32-bit
            Console.WriteLine(sizeof(nuint)); // output: 8 on 64-bit, 4 on 32-bit
            Console.WriteLine(sizeof(Span<int>));  // output: 16 on 64-bit, 12 on 32-bit
        }
    }

    static unsafe void DisplaySizeOf<T>() where T : unmanaged
    {
        Console.WriteLine($"Size of {typeof(T)} is {sizeof(T)}");
    }
}

O operador sizeof retorna o número de bytes alocados pelo common language runtime na memória gerenciada. Para tipos struct, esse valor inclui todo o preenchimento, como demonstra o exemplo anterior. O resultado do operador sizeof pode ser diferente do resultado do método Marshal.SizeOf, que retorna o tamanho de um tipo na memória não gerenciada.

Importante

O valor retornado por sizeof pode ser diferente do resultado de Marshal.SizeOf(Object), que retorna o tamanho do tipo na memória não gerenciada.

Especificação da linguagem C#

Para obter mais informações, confira a seção O operador sizeof, nas especificações da linguagem C#.

Consulte também

  • Last updated on