Массивы, куча и стек и типы значений

да массив будет расположен в куче.

входы внутри массива не будут помещены в коробку. Просто потому, что тип значения существует в куче, не обязательно означает, что он будет упакован. Бокс будет происходить только тогда, когда тип значения, например int, присваивается ссылке типа object.

не коробка:

int i = 42;
myIntegers[0] = 42;

окна:

object i = 42;
object[] arr = new object[10];  // no boxing here 
arr[0] = 42;

вы также можете проверить сообщение Эрика на этом тема:

• http://blogs.msdn.com/ericlippert/archive/2009/05/04/the-stack-is-an-implementation-detail-part-two.aspx

чтобы понять, что происходит, вот некоторые факты:

• "объект" всегда выделяется в куче.
• куча содержит только объекты.
• типы значений либо выделяются в стеке, либо являются частью объекта в куче.
• массив-это объект.
• массив может содержать только типы значений.
• ссылка на объект типа значения.

Итак, если у вас есть массив целых чисел, массива выделенный в куче и целые числа, которые он содержит, является частью объекта массива в куче. Целые числа находятся внутри объекта массива в куче, а не как отдельные объекты, поэтому они не упакованы.

Если у вас есть массив строк, это действительно массив ссылок на строки. Поскольку ссылки являются типами значений, они будут частью объекта массива в куче. Если вы помещаете строковый объект в массив, вы фактически помещаете ссылку на строковый объект в массив и строку это отдельный объект в куче.

я думаю, что в основе вашего вопроса лежит непонимание о ссылочных и ценностных типах. Это то, с чем, вероятно, боролся каждый разработчик .NET и Java.

массив-это просто список значений. Если это массив ссылочного типа (скажем string[]), то массив представляет собой список ссылок на различные string объекты в куче, а ссылка-это стоимостью ссылочного типа. Внутренне эти ссылки реализуются как указатели на адрес в памяти. Если вы хотите визуализировать это, такой массив будет выглядеть так в памяти (в куче):

[ 00000000, 00000000, 00000000, F8AB56AA ]

массив string, который содержит 4 ссылки string объекты в куче (числа здесь шестнадцатеричные). В настоящее время только последний string фактически указывает на что-либо (память инициализируется для всех нулей при выделении), этот массив в основном будет результатом этого кода в C#:

string[] strings = new string[4];
strings[3] = "something"; // the string was allocated at 0xF8AB56AA by the CLR

выше массив будет в 32-битной программе. В 64-битной программе ссылки будут в два раза больше (F8AB56AA будет 00000000F8AB56AA).

если у вас есть массив типов значений (скажем int[]), то массив представляет собой список целых чисел, как стоимостью типа значения и само значение (отсюда и название). Визуализация такого массива будет такой:

[ 00000000, 45FF32BB, 00000000, 00000000 ]

это массив из 4 целых чисел, где только второй int присваивается значение (1174352571, которое является десятичным представлением этого шестнадцатеричного числа), а остальные целые числа будут равны 0 (как я уже сказал, память инициализируется до нуля и 00000000 в шестнадцатеричном виде равно 0 в десятичном). Код, который создал этот массив будет:

 int[] integers = new int[4];
 integers[1] = 1174352571; // integers[1] = 0x45FF32BB would be valid too

этой int[] массив также будет храниться в куче.

в качестве другого примера, память a short[4] массив будет выглядеть это:

[ 0000, 0000, 0000, 0000 ]

как стоимостью на short - это 2-байтовое число.

где хранится тип значения, это просто деталь реализации, как Эрик Липперт очень хорошо объясняет здесь, не присущие различиям между значениями и ссылочными типами (что является различием в поведении).

когда вы передаете что-то методу (будь то ссылочный тип или тип значения), то a скопировать из стоимостью типа фактически передается методу. В случае ссылочного типа,стоимостью является ссылкой (думайте об этом как о указателе на часть памяти, хотя это также является деталью реализации), а в случае типа значения значение-это сама вещь.

// Calling this method creates a copy of the *reference* to the string
// and a copy of the int itself, so copies of the *values*
void SomeMethod(string s, int i){}

бокс происходит только если вы преобразование тип значения в ссылочный тип. Этот код коробки:

object o = 5;

массив целых чисел выделяется в куче, ни больше, ни меньше. myIntegers ссылается на начало раздела, где выделяются ints. Эта ссылка находится в стеке.

Если у вас есть массив объектов ссылочного типа, таких как тип объекта, myObjects[], расположенный в стеке, будет ссылаться на кучу значений, которые ссылаются на сами объекты.

подводя итог, если вы передаете myIntegers в некоторые функции, вы только передаете ссылка на место, где выделяется реальная связка целых чисел.

в вашем примере кода нет бокса.

типы значений могут жить в куче, как и в вашем массиве ints. Массив выделяется в куче и хранит ints, которые являются типами значений. Содержимое массива инициализируется по умолчанию (int), которое оказывается равным нулю.

рассмотрим класс, содержащий тип значения:

    class HasAnInt
    {
        int i;
    }

    HasAnInt h = new HasAnInt();

переменная h относится к экземпляру HasAnInt, который живет в куче. Просто так получилось, что он содержит тип значения. Это совершенно нормально, " я " просто живет в куче, поскольку она содержится в классе. В этом примере также нет бокса.

достаточно было сказано всеми, но если кто-то ищет четкий (но неофициальный) образец и документацию о куче, стеке, локальных переменных и статических переменных, обратитесь к полной статье Джона Скита о память в .NET-что идет куда

выдержка:

1. каждая локальная переменная (т. е. одна объявленная в методе) хранится в стеке. Что включает в себя переменные ссылочного типа переменной сам находится в стеке, но помните, что значение переменной ссылочного типа является только ссылкой (или нулем), а не самим объектом. Параметры метода также считаются локальными переменными, но если они объявлены с модификатором ref, они не получают свой собственный слот, а совместно используют слот с переменной, используемой в вызывающем коде. См. мою статью о передаче параметров для получения более подробной информации.

2. переменные экземпляра для ссылочного типа всегда в куче. Вот где сам объект "живет".

3. переменные для типа значения хранятся в том же контексте, что переменная, которая описывает тип значения. Слот памяти для экземпляра фактически содержит слоты для каждого поля в экземпляре. Это означает (учитывая предыдущие две точки), что переменная структуры, объявленная в методе, всегда будет находиться в стеке, тогда как переменная структуры, которая является полем экземпляра класса, будет находиться в куче.

4. каждая статическая переменная хранится в куче, независимо от того, объявлена ли она в ссылочном типе или типе значения. Существует только один слот в общей сложности независимо от того, сколько экземпляров создаются. (Там не должны быть какие-либо экземпляры, созданные для этого одного слота, чтобы существовать, хотя.) Детали того, в какой именно куче живут переменные, сложны, но подробно объясняются в статье MSDN по этому вопросу.

это иллюстрации, изображающие выше ответ @P Daddy

и я проиллюстрировал соответствующее содержание в моем стиле.