Размеры структур на 32 битах и 64 битах

Question

Размеры структур на 32 битах и 64 битах

Вы можете попробовать этот код. Следуйте коду в разделе CSS.

div {
  display: inline-block;
  padding: 2vw;
  background-color: green;
}

table {
  width: 70vw;
  background-color: white;
}

<div>
    <table border="colapsed">
      <tr>
        <td>Apple</td>
        <td>Banana</td>
        <td>Strawberry</td>
      </tr>
      <tr>
        <td>Apple</td>
        <td>Banana</td>
        <td>Strawberry</td>
      </tr>
      <tr>
        <td>Apple</td>
        <td>Banana</td>
        <td>Strawberry</td>
      </tr>
      
    </table>
</div>

6

.net architecture struct

задан thecoop 27 July 2009 в 16:15

3 ответа

Это не постоянное значение, это просто рекомендация, практическое правило. В зависимости от конкретной ситуации 24 или даже 32 байта могут быть вполне оправданными, но если ваша структура становится настолько большой, вы действительно должны спросить себя, подходит ли она в качестве структуры в первую очередь. Это может быть - в этом случае копирование этих 32 байтов каждый раз, когда вы выполняете присваивание или передаете аргумент в метод (и т. Д.), Может быть правильным поступком; в других случаях вам действительно следует использовать класс.

Что касается того, как вы определяете, насколько велика ваша структура - обычно это довольно очевидно, потому что обычно тип значения содержит только другие типы значений. Если ваша структура содержит ссылки (или IntPtr / UIntPtr ), это большая проблема - но это ' довольно редко. (Как указывает Мердад, существует также проблема заполнения ради выравнивания.)

С другой стороны, я нахожу крайне редко, что я все равно хочу написать свою собственную структуру. Какая у вас ситуация?

7

ответ дан 8 December 2019 в 17:25

В .Net большинство типов не меняют размер между 32- и 64-битными программами. Единственные 2 типа значений, определенных фреймворком, которые будут изменять свой размер в зависимости от платформы:

IntPtr
UIntPtr

Если у вас нет одного из этих типов прямо или косвенно в вашей структуре, он не должен изменять размер между платформами. .

Как указал Мердад, два других класса полей, размер которых будет изменяться в зависимости от платформы, - это

Указатели
Типы ссылок

Все эти типы будут меняться точно так же. 4 байта на 32-битной платформе и 8 байтов на 64-битной платформе.

4

ответ дан 8 December 2019 в 17:25

Другие вопросы по тегам:

.net architecture struct

Похожие вопросы:

score 3 · Accepted Answer

Да, размер структуры зависит от архитектуры. 32-битные структуры C # выровнены по 4-байтовым границам, а в 64-битных - по 8-ми байтам.

Пример:

struct Foo
{
   int bar;
}

Экземпляры этой структуры занимают 4 байта в 32-битных процессах и 8 байтов в 64-битных процессах, даже если "int bar" занимает всего 4 байта как в 32-битных, так и в 64-битных процессах.

Обновление:

Я провел некоторое тестирование с этим. Я написал этот код:

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

В качестве 64-битного процесса я получаю следующий результат:

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

В качестве 32-битного процесса я получаю следующий результат:

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

Наблюдения:

Простая структура Bar, кажется, занимает 4 байта как для 32-битных, так и для 64-битных процессов
Другая структура, Foo, похоже, занимает 8 байтов на 32-битной (4 байта для int и 4 байта для ссылки на Uri), но 16 байтов на 64-битную (4 байта для int, 8 байтов для ссылки на Uri и я думаю, 4 байта для выравнивания)