Megosztás:

sizeof operátor – egy adott típus memóriaigényének meghatározása

Az sizeof operátor egy adott típusú változó által elfoglalt bájtok számát adja vissza. A biztonságos kódban az sizeof operátor argumentumának egy beépített , nem felügyelt típusnak kell lennie, amelynek mérete nem platformfüggő.

A C# nyelv referenciadokumentuma a C# nyelv legújabb kiadású verzióját ismerteti. Emellett a közelgő nyelvi kiadás nyilvános előzetes verziójú funkcióinak kezdeti dokumentációját is tartalmazza.

A dokumentáció azonosítja azokat a funkciókat, amelyeket először a nyelv utolsó három verziójában vagy az aktuális nyilvános előzetes verziókban vezetnek be.

Jótanács

Ha meg szeretné tudni, hogy mikor jelent meg először egy funkció a C#-ban, tekintse meg a C# nyelvi verzióelőzményeiről szóló cikket.

Az alábbi táblázatban bemutatott kifejezések fordításkor kiértékelése a megfelelő állandó értékekre történik, és nem igényel nem biztonságos környezetet:

Kifejezés Állandó érték
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

Az előző táblázatban szereplő típusok mérete fordítási időállandó.

A nem biztonságos kódban bármilyen nem típustvoid használhatsizeof, beleértve a típusparaméterekből létrehozott típusokat is.

  • A hivatkozás vagy a mutató típusa a hivatkozás vagy a mutató mérete, nem pedig annak az objektumnak a mérete, amelyre hivatkozhat.
  • A nem felügyelt vagy nem felügyelt értéktípus mérete az ilyen érték mérete.
  • Egy típus mérete ref struct az érték mérete. Minden mező mérete ref egy hivatkozás vagy mutató mérete, nem pedig annak az értéknek a mérete, amelyre hivatkozik.

Az alábbi példa a sizeof operátor használatát mutatja be:

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)}");
    }
}

Az sizeof operátor a közös nyelvi futtatókörnyezet által lefoglalt bájtok számát adja vissza a felügyelt memóriában. A szerkezettípusok esetében ez az érték bármilyen kitöltést tartalmaz, ahogy az előző példa is mutatja. Az operátor eredménye sizeof eltérhet a Marshal.SizeOf metódus eredményétől, amely a nem felügyelt memória típusának méretét adja vissza.

Fontos

A visszaadott sizeof érték eltérhet az eredménytől Marshal.SizeOf(Object), amely a nem felügyelt memória típusának méretét adja vissza.

C# nyelvspecifikáció

További információ: A C# nyelvspecifikációoperátorainak mérete.

Lásd még

  • Last updated on