RAM может обработать различные размеры типа данных?

На обычном современном компьютере вся память имеет байтовую адресацию. То есть каждому месту хранения байтового размера в ОЗУ присвоен уникальный номер. Если вы хотите сохранить однобайтовое значение, такое как bool (хотя bool s не требуются, чтобы были одним байтом в C ++, они обычно ), требуется одно место хранения, скажем, 42.

Если вы хотите сохранить что-то больше одного байта, скажем int , тогда потребуется несколько последовательных мест хранения. Например, если ваш тип int имеет длину 16 бит (2 байта), то половина его будет храниться в ячейке 42, а другая половина - в ячейке 43. Это обобщается на более крупные типы. Допустим, у вас есть 64-битный (8-байтовый) тип long long int . Значение этого типа может храниться в ячейках 42, 43, 44, 45, 46, 47, 48 и 49.

Есть некоторые более сложные соображения, называемые «выравниванием», которые некоторые типы процессоров должны учитывать. Например, у процессора может быть правило, согласно которому двухбайтовое значение должно начинаться с четного адреса или четырехбайтовое значение должно начинаться с адреса, который делится на 4. Ваш компилятор позаботится о деталях этого для тебя.

Компилятор также знает длину каждого типа, поэтому, когда он генерирует машинный код для вашей программы, он будет знать, с какого адреса начинается хранилище для каждой переменной, и он будет знать, сколько последовательных байтов хранится в переменной. .

С другой стороны, «регистры» - это то, что существует в процессоре, а не в оперативной памяти, и обычно имеют фиксированный размер.Регистры процессора можно использовать для хранения значения, полученного из ОЗУ. Например, если ваш процессор имеет 32-битные (4-байтовые) регистры, то значение bool , загруженное из ОЗУ, по-прежнему будет занимать весь 4-байтовый регистр, даже если оно занимало только один байт, когда было в ОЗУ. .

Если под словом «поддержка» вы имеете в виду, имеет ли ОЗУ на компьютере собственный блок памяти, соответствующий каждому размеру, то ответ будет «это зависит от машины и компилятор ».

Современные машины обычно имеют минимальный размер адресуемой памяти, кратный 8 битам (8/16/32/64 бит). Компиляторы могут использовать любой из этих размеров для хранения данных и управления ими. Компилятор может оптимизировать использование хранилища и регистров, но это не обязательно.

Оперативная память не особо заботится о размерах типов данных. Она просто хранит данные в байтах. Центральный процессор контролирует основные типы данных, зная, сколько байт они имеют. Создавая, например, int, центральный процессор решает использовать, например, 4 или 8 байт (32 или 64-битная архитектура соответственно)

Один бит не может быть адресован, но вы можете сделать пользовательскую структуру, где в одном байте будет храниться 8 булевых чисел. В C++ это можно использовать с помощью битовых полей.

Предположительно вы имеете в виду кеш? Просто любопытно, почему вас беспокоят размеры структур данных, вы программируете для встраиваемых систем? Обычно это единственный раз, когда стоит беспокоиться об объеме памяти.

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

0x0001 
0x0010 
0x0100 
0x1000 

отделены друг от друга и могут проверяться независимо от других. Люди делают это все время, чтобы сэкономить немного места. Это то, что вы пытаетесь выяснить?

Так, например, если каждое логическое значение занимает один байт пространства, то очевидно, что используется только один бит на байт. Таким образом, если вы объедините в цепочку 8 бит, он будет занимать только один байт пространства.

Но не забывайте, что каждая переменная в памяти также имеет своего рода маршалинг (более очевидный в .NET, чем в языках «нижнего» уровня, но всегда есть что-то, отслеживающее используемые переменные). Как и в случае с C #, для одного байта требуется 3 байта ОЗУ.

Но оперативная память передается блоком, который, как я понимаю, намного больше одного байта. Обычно это измеряется как минимум словами, а нормальный размер - 32, 64 или 128 бит за раз. Эти числа зависят от платформы.

Большинство массового оборудования имеет память с байтовой адресацией. Посмотрев немного глубже, мы увидим, что регистры процессора имеют разрядность (32 или 64 бита для повседневных задач). Затем кеши и шины работают с этими блоками (64 или 128 байтов). Вы можете попробовать воспользоваться этим, но вам потребуется довольно подробное понимание оборудования, и вы будете привязаны к определенной платформе. С другой стороны, вам не нужно использовать это преимущество, поскольку ваш компилятор уже это делает.

Какое отношение это имеет к ОЗУ?

Логическое значение может быть истинным или ложным, которое обычно представляется как 0 или 1 (1 бит). Символы могут иметь разные размеры в зависимости от используемой кодировки. ASCII использует 7 бит. Unicode использует до 32 бит. Целые числа - это целые числа, часто поддерживающие диапазон -2 ^ 31 .... 2 ^ 31-1 (32 бита), но они бывают и других размеров.

Вы можете использовать битовые поля C++, если хотите, но вы будете одним из немногих на этой планете, кто это делает (технически, битовые поля хорошо определены в C, но они никогда особо не использовались)

То, как происходит доступ к оперативной памяти, скрыто для вас компилятором C++ по веским причинам. Есть случаи, когда вы хотите оптимизировать это, но они крайне редки. В современном мире огромных объемов оперативной памяти на клиентских ПК просто не стоит заниматься микрооптимизацией.

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

Если вы хотите немного технической информации:

На уровне машинного языка это зависит от процессора. Например, линейка процессоров Motorola 680x0 позволяет делать

move.l
move.w
move.b

чтение и запись различных "единиц" оперативной памяти (длинна/слово/байт). Процессор по-разному смотрит на свою оперативную память в зависимости от того, какую инструкцию он обрабатывает. Некоторые встроенные процессоры могут даже использовать 4 бита в качестве наименьшей единицы.

Компьютерная память организована в "слова" - последовательность байтов заданного размера (часто двухсильного). Память обычно читается и записывается в этих единицах, которые часто совместимы с размером регистров и встроенной поддержкой арифметических операторов процессора. Это обычно является источником "разрядности" машины (например, 32-битный процессор, 64-битный процессор, старые 8-битные игровые приставки).

Конечно, часто требуется размер, отличный от размера родного слова. Машинные инструкции и интеллектуальное кодирование позволяют разбивать эти слова на более мелкие единицы, применяя различные логические операторы битового уровня, или объединять их в более крупные единицы, "комбинируя" несколько слов.

Например, если у вас есть 32-битное слово, вы можете выполнить AND слова против шаблона типа 0xff0000ff, чтобы получить первый и последний байт в этом слове, или 0x0000ffff, чтобы получить только содержимое второго 16-битного int.

В случае с bools принято использовать память как битовую карту. Вы можете поместить X "bools" в X-битное слово и получить доступ к определенному биту путем AND или OR против "маски", которая относится к этому bool. Например, 1 - первый бит, 2 - второй бит, 4 - четвертый бит и т.д.

В большинстве машин нежелательно разбивать меньший тип данных на два слова (это называется выравниванием).

Когда вы работаете с языком более высокого уровня, таким как C или C++, вам обычно не нужно беспокоиться обо всех этих вещах, связанных с организацией памяти. Если вы выделяете int, short и double, компилятор сгенерирует соответствующий машинный код. Вы делаете это напрямую только тогда, когда хотите разумно организовать вещи в динамически выделяемой памяти, например, при ручной реализации растровой карты.

При работе с блоками большего размера, чем размер родного слова, компилятор снова будет обрабатывать большинство вещей за вас. Например, на 32-битной машине вы можете легко обрабатывать 32-битные операции int, но для выполнения того же кода на 8-битной или 16-битной машине компилятор будет генерировать код для выполнения более мелких операций и объединять их для получения результата. Отчасти поэтому обычно считается целесообразным запускать 64-битную ОС на 64-битной машине, поскольку в противном случае вы будете выполнять несколько инструкций и операций чтения/записи для имитации 64-битной системы на 32-битной, а не одну инструкцию или доступ к памяти.