Størrelser av structs på 32 bits og 64 bits

stemmer
5

I .NET struct retningslinjer for design , det gir maksimal fornuftig størrelse med en struct som 16 bytes. Hvordan avgjør dere hvor stor struct er, og det er berørt av arkitekturen programmet kjører på? Er denne verdien 32-bit bare, eller for begge arkitekturene?

Publisert på 27/07/2009 klokken 16:15
kilden bruker
På andre språk...                            


3 svar

stemmer
6

Det er ikke en hard-og-rask verdi - det er bare en retningslinje, en tommelfingerregel. Avhengig av den eksakte situasjonen, kan 24 eller 32 bytes fortsatt være helt forsvarlig - men hvis din struct får så stort bør du virkelig spørre deg selv om det er riktig som en struct i første omgang. Det kan være - i så fall ta treffet med å kopiere disse 32 bytes rundt når du utfører et oppdrag eller passere et argument til en metode (etc) kan være den riktige tingen å gjøre; i andre tilfeller bør du virkelig bruke en klasse.

Som for hvordan du avgjør hvor stor struct er - vanligvis er det ganske åpenbart, fordi vanligvis en verditype bare inneholder andre verdityper. Hvis struct inneholder referanser (eller en IntPtr/ UIntPtr), som er mer av et problem - men det er ganske sjelden. (Som Mehrdad påpeker, det er også spørsmålet om padding på grunn av justering.)

Så igjen, jeg synes det er ekstremt sjelden at jeg ønsker å skrive min egen struct uansett. Hva er din situasjon?

Svarte 27/07/2009 kl. 16:17
kilden bruker

stemmer
4

I Net de fleste typer ikke endrer størrelse mellom 32 og 64 bit program. Bare 2 verdityper som er definert ved rammen som vil endre sin størrelse basert på plattformen finnes

  • IntPtr
  • UIntPtr

Med mindre du har en av disse direkte eller indirekte i din struct, bør det ikke endre størrelse mellom plattformer.

Som Mehrdad påpekt, de to andre klasser av felt som vil endre størrelsen basert på plattformen er

  • pekere
  • referanse typer

Alle disse typene selv vil endre seg i nøyaktig samme måte. 4 byte på en 32 bits plattform og 8 byte på en 64 bits plattform.

Svarte 27/07/2009 kl. 16:18
kilden bruker

stemmer
3

Ja, er på størrelse med en struct påvirket av arkitektur. C # structs i 32bit er justert på 4 byte grenser, og i 64bit de er 8 byte justert.

Eksempel:

struct Foo
{
   int bar;
}

Forekomster av denne struct vil ta opp 4 byte i 32bit prosesser og 8 byte i 64bit prosesser, selv om "int bar" tar bare fire byte på både 32bit og 64bit prosesser.

Oppdater:

Jeg gjorde noen tester med dette. Jeg skrev denne koden:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication3
{
    struct Bar
    {
        int a;
    }

    struct Foo
    {
        Uri uri;
        int a;
    }

    class Program
    {
        static void Main(string[] args)
        {
            Foo[] foo;
            long fooBefore = System.GC.GetTotalMemory(true);
            foo = new Foo[10];
            long fooAfter = System.GC.GetTotalMemory(true);

            Bar[] bar;
            long barBefore = System.GC.GetTotalMemory(true);
            bar = new Bar[10];
            long barAfter = System.GC.GetTotalMemory(true);

            Foo aFoo = new Foo();
            Bar aBar = new Bar();

            System.Console.Out.WriteLine(String.Format("[Foo] Size of array of 10: {0}, Marshal size of one: {1}", fooAfter - fooBefore, System.Runtime.InteropServices.Marshal.SizeOf(aFoo)));
            System.Console.Out.WriteLine(String.Format("[Bar] Size of array of 10: {0}, Marshal size of one: {1}", barAfter - barBefore, System.Runtime.InteropServices.Marshal.SizeOf(aBar)));
            System.Console.ReadKey();
        }
    }
}

Som en 64bit prosess, får jeg denne produksjonen:

[Foo] Size of array of 10: 208, Marshal size of one: 16
[Bar] Size of array of 10: 88, Marshal size of one: 4

Som en 32bit prosess, får jeg denne produksjonen:

[Foo] Size of array of 10: 92, Marshal size of one: 8
[Bar] Size of array of 10: 64, Marshal size of one: 4

observasjoner:

  • Den enkle struct, Bar, ser ut til å ta 4 byte på både 32bit og 64bit prosesser
  • Den andre struct, Foo, ser ut til å ta 8 byte på 32 bit (4 byte for int og 4 byte for referanse til den Uri), men 16 byte på 64-bits (4 byte for int, 8 bytes for referansen til Uri, og jeg tror 4 byte for justering)
Svarte 27/07/2009 kl. 16:25
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more