Condividi tramite

Operatore sizeof: determinare le esigenze di memoria per un determinato tipo

L'operatore sizeof restituisce il numero di byte occupati da una variabile di un determinato tipo. Nel codice sicuro, l'argomento dell'operatore sizeof deve essere il nome di un tipo non gestito predefinito la cui dimensione non è dipendente dalla piattaforma.

Il riferimento al linguaggio C# documenta la versione rilasciata più di recente del linguaggio C#. Contiene anche la documentazione iniziale per le funzionalità nelle versioni di anteprima pubblica per la prossima versione del linguaggio di programmazione.

La documentazione identifica tutte le funzionalità introdotte nelle ultime tre versioni della lingua o nelle anteprime pubbliche correnti.

Suggerimento

Per trovare quando una funzionalità è stata introdotta per la prima volta in C#, vedere l'articolo sulla cronologia delle versioni del linguaggio C#.

Le espressioni presentate nella tabella seguente vengono valutate in fase di compilazione con i valori costanti corrispondenti e non richiedono un contesto non sicuro:

Espressione Valore costante
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

La dimensione dei tipi nella tabella precedente è una costante in fase di compilazione.

Nel codice unsafe è possibile usare sizeof in qualsiasivoid tipo, inclusi i tipi costruiti dai parametri di tipo.

  • La dimensione di un tipo riferimento o puntatore è la dimensione di un riferimento o di un puntatore, non la dimensione dell'oggetto a cui può fare riferimento.
  • La dimensione di un tipo valore, non gestita o meno, è la dimensione di tale valore.
  • La dimensione di un ref struct tipo è la dimensione del valore. La dimensione di ogni ref campo è la dimensione di un riferimento o di un puntatore, non la dimensione del valore a cui fa riferimento.

Nell'esempio seguente viene illustrato l'utilizzo dell'operatore 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)}");
    }
}

L'operatore sizeof restituisce il numero di byte allocati da Common Language Runtime nella memoria gestita. Per tipi di struct, tale valore include qualsiasi spaziatura interna, come illustrato nell'esempio precedente. Il risultato dell'operatore sizeof può differire dal risultato del metodo Marshal.SizeOf, che restituisce le dimensioni di un tipo in memoria non gestita.

Importante

Il valore restituito da sizeof può differire dal risultato di Marshal.SizeOf(Object), che restituisce le dimensioni del tipo in memoria non gestita.

Specifica del linguaggio C#

Per ulteriori informazioni, consultare la sezione Operatore sizeof delle specifiche del linguaggio C# .

Vedere anche

  • Last updated on