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

int[] myIntegers;
myIntegers = new int[100];

У наведеному вище коді новий int [100] генерує масив на купі? З того, що я прочитав у CLR через c #, відповідь - так. Але те, що я не можу зрозуміти, - це те, що відбувається з фактичним int всередині масиву. Оскільки вони є типовими значеннями, я б здогадувався, що їх доведеться покласти в ящик, як я можу, наприклад, передати мій Integers іншим частинам програми, і це буде захаращувати стек, якби вони залишалися на ньому весь час . Або я помиляюся? Я б здогадувався, що вони просто потрапили в бокс і проживуть на купі до тих пір, поки масив існував.

Ваш масив розміщений на купі, а вкладені елементи не позначені коробкою.

Джерело вашої плутанини, ймовірно, тому, що люди сказали, що типи посилань виділяються на купі, а типи значень виділяються на стеку. Це не зовсім точне уявлення.

Всі локальні змінні та параметри виділяються на стеку. Сюди входять і типи значень, і типи посилань. Різниця між ними полягає лише в тому, що зберігається у змінній. Не дивно, що для типу значень значення типу зберігається безпосередньо у змінній, а для еталонного типу значення типу зберігається у купі, а посилання на це значення - це те, що зберігається у змінній.

Те саме стосується полів. Коли пам'ять виділяється для екземпляра сукупного типу (a classабо a struct), вона повинна містити сховище для кожного свого поля екземпляра. Для полів типу посилання цей сховище містить лише посилання на значення, яке було б виділено пізніше. Для полів типу значень це сховище містить фактичне значення.

Отже, враховуючи такі типи:

class RefType{
    public int    I;
    public string S;
    public long   L;
}

struct ValType{
    public int    I;
    public string S;
    public long   L;
}

Значення кожного з цих типів потребували б 16 байтів пам'яті (якщо припустити розмір 32-бітного слова). Поле Iв кожному випадку займає 4 байти, щоб зберігати його значення, поле Sзаймає 4 байти, щоб зберігати його посилання, а поле Lзаймає 8 байт, щоб зберігати його значення. Тож пам'ять про значення обох RefTypeі ValTypeвиглядає приблизно так:

 0 ┌────────────────────┐
   │ Я │
 4 ├────────────────────┤
   │ S │
 8 ├────────────────────┤
   │ L │
   │ │
16 └────────────────────┘

Тепер , якщо у вас три локальні змінні в функції, типів RefType, ValTypeі int[], як це:

RefType refType;
ValType valType;
int[]   intArray;

тоді ваш стек може виглядати приблизно так:

 0 ┌────────────────────┐
   │ refType │
 4 ├────────────────────┤
   ValType │
   │ │
   │ │
   │ │
20 ├────────────────────┤
   │ intArray │
24 └────────────────────┘

Якщо ви присвоїли значення цим локальним змінним, наприклад:

refType = new RefType();
refType.I = 100;
refType.S = "refType.S";
refType.L = 0x0123456789ABCDEF;

valType = new ValType();
valType.I = 200;
valType.S = "valType.S";
valType.L = 0x0011223344556677;

intArray = new int[4];
intArray[0] = 300;
intArray[1] = 301;
intArray[2] = 302;
intArray[3] = 303;

Тоді ваш стек може виглядати приблизно так:

 0 ┌────────────────────┐
   │ 0x4A963B68 │ - купа купи `refType`
 4 ├────────────────────┤
   │ 200 │ - значення `valType.I`
   │ 0x4A984C10 │ - купа купи `valType.S`
   │ 0x44556677 │ - низький 32-бітний бік `valType.L`
   │ 0x00112233 │ - високий 32-бітний бік `valType.L`
20 ├────────────────────┤
   │ 0x4AA4C288 │ - купа адреси `intArray`
24 └────────────────────┘

Пам'ять за адресою 0x4A963B68(значення refType) буде приблизно таким:

 0 ┌────────────────────┐
   │ 100 │ - значення `refType.I`
 4 ├────────────────────┤
   │ 0x4A984D88 │ - купа адреси `refType.S`
 8 ├────────────────────┤
   │ 0x89ABCDEF │ - низький 32-бітний бік `refType.L`
   │ 0x01234567 │ - високий 32-бітний бік `refType.L`
16 └────────────────────┘

Пам'ять за адресою 0x4AA4C288(значення intArray) буде приблизно таким:

 0 ┌────────────────────┐
   │ 4 │ - довжина масиву
 4 ├────────────────────┤
   │ 300 │ - `intArray [0]`
 8 ├────────────────────┤
   │ 301 │ - `intArray [1]`
12 ├────────────────────┤
   │ 302 │ - `intArray [2]`
16 ├────────────────────┤
   │ 303 │ - `intArray [3]`
20 └────────────────────┘

Тепер, якщо ви перейшли intArrayдо іншої функції, значенням, висунутим на стек, була б 0x4AA4C288адреса масиву, а не копія масиву.

Так, масив буде розташований на купі.

Вкладиші всередині масиву не будуть полями. Тільки тому, що тип значень існує на купі, не обов'язково означає, що він буде розміщений у полі. Бокс відбуватиметься лише тоді, коли тип значення, наприклад int, присвоєно посиланням на об'єкт типу.

Наприклад

Не вказує:

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

Коробки:

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

Ви також можете перевірити публікацію Еріка на цю тему:

• Стек - це деталізація реалізації, частина друга

Щоб зрозуміти, що відбувається, ось деякі факти:

• Об'єкт завжди виділяється на купі.
• Купа містить лише предмети.
• Типи значень або виділяються на стеку, або частина об'єкта в купі.
• Масив - це об'єкт.
• Масив може містити лише типи значень.
• Посилання на об'єкт - тип значення.

Отже, якщо у вас є масив цілих чисел, масив виділяється на купу, а цілі числа, які він містить, є частиною об’єкта масиву на купі. Цілі числа знаходяться всередині об’єкта масиву на купі, а не як окремі об'єкти, тому вони не розміщуються в коробці.

Якщо у вас є масив рядків, це дійсно масив посилань на рядок. Оскільки посилання - це типи значень, вони будуть частиною об’єкта масиву на купі. Якщо ви розмістите об’єкт рядка в масиві, ви фактично помістите посилання на об'єкт рядка в масиві, а рядок - це окремий об'єкт у купі.

Я думаю, що в основі вашого питання лежить непорозуміння щодо еталонних та ціннісних типів. З цим, мабуть, боролися всі розробники .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[]масив також буде зберігатися у купі.

Як інший приклад, пам'ять short[4]масиву виглядатиме так:

[ 0000, 0000, 0000, 0000 ]

Як значення аshort - це 2-байтне число.

Там, де зберігається тип значення, - це лише деталь реалізації, як тут дуже добре пояснює Ерік Ліпперт , а не притаманні різниці між значеннями та еталонними типами (що є різницею в поведінці).

Коли ви що - то передати в метод (будь то контрольний тип або тип значення) , то копія з значення типу фактично передається методу. У випадку еталонного типу значення - це посилання (подумайте про це як на вказівник на частину пам'яті, хоча це також є детальною частиною реалізації), а у випадку типу типу значення - сама річ.

// 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;

Це ілюстрації із зображенням вищевідповіді від @P Daddy

І я проілюстрував відповідний зміст у своєму стилі.

Масив цілих чисел виділяється на купу, нічого більше, нічого менше. myIntegers посилаються на початок розділу, де розміщені вставки. Ця посилання знаходиться на стеці.

Якщо у вас є масив об'єктів опорного типу, як, наприклад, тип Object, myObjects [], розташований на стеці, буде посилатися на купу значень, на які посилаються самі об'єкти.

Підводячи підсумок, якщо ви передаєте myIntegers деяким функціям, ви передаєте лише посилання на місце, де виділено реальну купу цілих чисел.

У вашому прикладі коду немає боксу.

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

Розглянемо клас, який містить тип значення:

    class HasAnInt
    {
        int i;
    }

    HasAnInt h = new HasAnInt();

Змінна h посилається на екземпляр HasAnInt, який живе на купі. Це просто буває, що містить тип значення. Це цілком нормально, "я" просто трапляється жити на купі, як це міститься в класі. У цьому прикладі також немає боксу.

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

Витяг:

1. Кожна локальна змінна (тобто одна, оголошена методом) зберігається у стеці. Це включає змінні типу опорного типу - сама змінна знаходиться в стеці, але пам’ятайте, що значення змінної типу посилання є лише посиланням (або нулем), а не самим об'єктом. Параметри методу також зараховуються до локальних змінних, але якщо вони оголошені за допомогою модифікатора ref, вони не отримують власний слот, а поділяють слот зі змінною, що використовується в коді виклику. Дивіться мою статтю про проходження параметрів для отримання більш детальної інформації.

2. Змінні екземпляри для еталонного типу завжди знаходяться в купі. Ось тут і живе сам об’єкт.

3. Змінні екземпляра для типу значення зберігаються в тому ж контексті, що і змінна, яка оголошує тип значення. Слот пам'яті для екземпляра ефективно містить слоти для кожного поля в екземплярі. Це означає (з огляду на два попередні пункти), що змінна структури, оголошена в методі, завжди буде знаходитись у стеці, тоді як структурна змінна, яка є полем екземпляра класу, буде у купі.

4. Кожна статична змінна зберігається в купі, незалежно від того, декларована вона в межах еталонного типу або типу значення. Всього лише один слот, незалежно від кількості створених екземплярів. (Для цього одного слоту не потрібно створювати жодних екземплярів.) Деталі того, на якому саме місці розміщуються змінні, складні, але детально пояснені в статті MSDN з цього питання.