Сколько памяти требуется

Обновлено: 21.11.2024

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

< td>1 < /tr> < тд >2G символов
Форма экспоненты Точное значение Приблизительное значение Байты биты (байты * 8) ints (Bytes/4) chars (Bytes/2)
2 0 1B 8b
2 1 2 2B 16b 1 символ
2 2 4 4B 32b 1 int 2 символа
2 10 1024 1 тысяча 1 КБ 8 КБ ~250 целых чисел ~500 символов
2 16 65 536 64 КБ 512 КБ 16 КБ целых 32K символов
2 20 1,048,576 1 миллион 1MB 8Mb 250K целых 500K символов
2 30 1,073,741,824 1 миллиард 1GB 8Gb 250M целых 500M символов
2 32 4,294,967,296 4 миллиарда 4GB 32Gb 1G целых
2 40 1,099,511,627,776 1 триллион 1ТБ 8Tb 250G целых 500G символов

Если вы забыли…

  • Типы данных представлены битами.
  • 8 бит составляют байт
  • 1 байт (или 8 бит) составляет логическое значение
  • 2 байта (или 16 бит) составляют символ
  • 4 байта (или 32 бита) составляют целое число
  • 8 байтов (или 64 бита) составляют длинный [это не показано на диаграмме]
  • В Java можно представить 2^16 (~65 000) символов.
  • Всего в Java существует 2^32 (~4 миллиарда) целочисленных представлений.
  • Каждый символ и целое число могут быть представлены в шестнадцатеричном формате.
  • \u0000, \uFFFF представляют собой символы, где каждый символ представляет собой байт
  • 0x00000000, 0xFFFFFFFF представляют целые числа, где каждый символ представляет собой байт
  • Каждое число 2^(10*n) преодолевает тысячный барьер.

Скажем, у вас есть N байтов для работы. Если мы хотим узнать, сколько целых чисел мы можем туда поместить, мы берем N/4, поскольку каждое целое число использует четыре байта.

Допустим, мы хотим разместить все целые числа в массиве в памяти. Сколько памяти нам нужно? мы берем все целые числа (2 ^ 32), а затем умножаем их на 4, поскольку каждое целое число представлено четырьмя байтами. Нам потребуется примерно 16 ГБ памяти, чтобы поместить все представимые целые числа в массив

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

примечание: все примитивные типы основаны на языке Java. Таблица является продолжением книги Гейл Лаакманн Макдауэлл «Полномочия двойки» в Crack the Coding Interview, 5-е издание

CIS3355: Структуры бизнес-данных
Осень 2008 г.

Что вы должны знать, прежде чем мы начнем:

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

Теперь мы готовы начать, и чтобы представить наше объяснение того, как целые числа хранятся в ОЗУ, давайте начнем с анализа следующего объявления программы c:

int x = "J", y = 1145, z;

При вводе предыдущего объявления программа ищет доступное место для хранения данных.

НО ГДЕ ЭТИ ЗНАЧЕНИЯ БУДУТ ХРАНИТЬСЯ.

Ну, все зависит от того, где есть свободное место. Однако с целыми числами вы должны иметь в виду, что они должны храниться в двух смежных байтах памяти. Невозможно сохранить часть целого числа, например, по адресу 1245, а оставшуюся часть по адресу 1520.

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

НО ЗАЧЕМ НУЖНЫ АДРЕСА 1254 И 1255, ЕСЛИ МЫ НИЧЕГО ТАМ НЕ СОХРАНИЛИ.

Ну, это очень просто, потому что в c данные хранятся временно, но когда они используются, местоположения не сбрасываются до нуля, вместо этого они сохраняют информацию, которая была сохранена ранее, до тех пор, пока вы не назначите новые значения в местоположениях. Это означает, что если бы мы распечатали содержимое этих двух мест, то была бы напечатана вся информация, хранившаяся там ранее.

Возможно, вы заметили, что переменная x содержит символ, для которого требуется всего 7 бит памяти. Но как его можно сохранить как целое число.

Единственное отличие состоит в том, что для целых чисел требуется 16 бит памяти, поэтому, чтобы сохранить символ как целое число, нам нужно будет добавлять нули перед первой единицей, пока мы не закончим 16 бит. Например, в этом случае символ J хранится как 00000000 01001010. Таким же образом мы можем распечатать целое число как символ, при этом мы будем смотреть на крайние правые 8 бит, определять хранящееся там числовое значение и распечатывать соответствующий символ ASCII.

Что произойдет, если мы присвоим значение, например 55 456, целочисленной переменной.

55, 456 — недопустимое значение, потому что помните, что целые числа берутся только из диапазона значений от -32 768 до 32 767. Однако c — это программа, которая даже при задании недопустимого значения будет выполнять операцию. В этой ситуации программа сделает следующее:

<р>1. Сначала он преобразует десятичное значение в двоичное:

<р>2. Затем он будет интерпретировать это число. Во-первых, поскольку первое число равно 1, оно кажется отрицательным.

<р>3. Затем для оценки мы берем два дополненных числа:

<р>4. Затем мы определяем значение 10011101100000 равным -10 080.

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

ЦЕЛЫЕ ЧАСТИ БЕЗ ЗНАКА; которые позволяют хранить значения от 0 до 65 535.

ДЛИННЫЕ; которые позволяют хранить значения от -2 147 483 648 до 2 147 483 647.

НЕ ПОДПИСАННЫЕ ДЛИННЫЕ СООБЩЕНИЯ; которые позволяют хранить значения от 0 до 4 294 967 296.

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

ПОЛЕЗНАЯ ИНФОРМАЦИЯ

Типы переменных.

< td align="left" width="311">-32 768 до 32 767 < tr align="left" rowspan="1">
Тип Размер Значения
короткое целое без знака 2 байта от 0 до 65 535
short int 2 байта
unsigned long int 4 байта от 0 до 4 294 967 295< /td>
long int 4 байта -2 147 483 648 до 2 147 483 647
int (16 бит) 2 байта -32 768 до 32 767
int (32 бита) 4 байта -2 147 483 648 до 2 147 483 647
целое число без знака (16 бит) 2 байта от 0 до 65 535< /td>
целое число без знака (32 бита) 2 байта от 0 до 4 294 967 295
char 1 байт 256 символов
float 4 байта от 1.2e-38 до 3.4e38
двойной 8 байт 2.2e-308 до 1.8e308

******ПРОВЕРЬТЕ СВОИ ЗНАНИЯ******

(Ответы внизу страницы)

Вопросы с несколькими вариантами ответов

1 . Если мы можем использовать только адреса 2653, 2654, 2655 и 2656, а адрес 2654 содержит числовое значение

значение 100. Если я запрошу unsigned int a='A', что произойдет?

a) используйте ячейку 2653 и 2655, поскольку для целых чисел требуется два байта, используется ячейка 2654.

b) используйте 2653, очистите ячейку 2654 и используйте их обе для хранения целого числа.

c) Это невозможно сделать, потому что целым числам нужны два смежных байта, а 'A' — это символ, который означает, что это только

требуется одно хранилище.

d) используйте 2655 и 2656 и сохраните двоичный файл

номер 0000 0000 0100 0001

<р> 2.Независимо от того, знаковые или беззнаковые, тип данных int требует ___________ памяти для каждой переменной.

А) Два байта

Б) Три байта

C) Шестнадцать бит

E) Ничего из вышеперечисленного

3 Если в двоичном коде значения 00011010 и 00111111 хранятся по адресам 2567 и 2568 соответственно, что

десятичное значение хранится по адресу 2568, если тип данных является целым числом?

а) 63, потому что это десятичное значение ASCII, связанное с двоичным значением 00111111.

c) 6719, потому что целые числа требуют 2 байта непрерывной памяти, поэтому оба адреса 2567 и 2568 должны быть

оценить, чтобы определить ответ.

г) Ничего из вышеперечисленного, у нас недостаточно информации для определения ответа.

Вопросы с краткими ответами

1. В чем разница между хранением символа и целого числа в оперативной памяти?

2. Можно ли хранить целое число в любом доступном месте в ОЗУ?

3. Как адрес переменной упоминается в ОЗУ?

4. Что произойдет, если я присвою отрицательное число переменной без знака? Рассмотрим следующую строку кода:

СВЯЗАННЫЕ ССЫЛКИ И ССЫЛКИ :

Ответы на вопросы для проверки ваших знаний.

Вопросы с несколькими вариантами ответов

Вопросы с краткими ответами

1. Целое число хранится так же, как символ в ОЗУ. Однако целое число требует больше места на 2 или 4 байта в зависимости от машины, а также непрерывной памяти для размещения целочисленного значения переменной.

<р> <я> 2. Да и НЕТ, целые числа могут храниться в любом доступном пространстве, если адреса в памяти непрерывны от начального байта до конечного байта.

<р> 3. Адрес переменной называется базовым местоположением переменной. Если у вас есть целое число, занимающее адреса 100 и 101, адрес переменной будет равен 100.

4. Отрицательное число будет оцениваться как битовая комбинация и присваиваться переменной. Затем значение этой переменной будет интерпретировано как число без знака. Таким образом, -1, чей битовый шаблон равен 11111111 11111111 (0xFF в шестнадцатеричном формате), будет оцениваться как беззнаковое значение 65,535< /tt>.

Очевидно, getsizeof() возвращает размер объекта в байтах, хотя этот размер одинаков для всех int в python?

Я знаю, что существуют длинные целые числа, и что они автоматически преобразуются в длинные целые при определенном значении в python, но сейчас меня просто интересуют целые числа.

В Java размер, который я получил, был 32-битным, то есть 4 байта.

Правильно ли это:

И это потому, что в python int больше методов и т. д.?

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

В этом случае не все 224 бита, которые вы видите, используются для представления целого числа; многие из них связаны с представлением объекта Python (в отличие от собственного значения в C-подобных языках).

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

поэтому типы данных между языками несопоставимы с точки зрения использования памяти?

В этом случае не все 224 бита, которые вы видите, используются для представления целого числа; многие из них связаны с представлением объекта Python (в отличие от собственного значения в C-подобных языках).

Я упомянул об этом (расплывчато) в OP - у них есть методы и т. д., которых, возможно, нет в других языках.

это потому, что у python int больше методов и т. д.?

Почти, но не совсем.

Внутри все объекты python содержат минимум счетчик ссылок, используемый сборщиком мусора, и указатель на объект типа [статически выделенный] (который, по сути, представляет собой массив указателей функций на методы доступны на объектах этого типа). Объекты с переменным размером (такие как list s, dict s и int с переменной точностью в python 3) также содержат значение размера.

Итак, в «заголовке» каждого объекта Python хранится 3 значения. На 32-битной платформе эти 3 значения, скорее всего, займут 3*32 бита, а на 64-битной платформе они займут 3*64 бита. Таким образом, любой объект Python переменного размера с нулевым размером будет занимать не менее 24 байта на 64-разрядной машине.

Кроме того, значение длинного целого числа Python фактически хранится в массиве 15- или 30-битных фрагментов (в зависимости от вашей сборки).В моей 64-битной сборке вы можете видеть, что размер целых чисел неуклонно увеличивается по мере того, как я увеличиваю их размер с шагом 30 бит.

Типы данных в c относятся к обширной системе, используемой для объявления переменных или функций различных типов. Тип переменной определяет, сколько места она занимает в памяти и как интерпретируется сохраненная битовая комбинация.

Типы в C можно классифицировать следующим образом:

Основные типы

Они являются арифметическими типами и подразделяются на: (а) целые типы и (б) типы с плавающей запятой.

Пронумерованные типы

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

Тип недействителен

Спецификатор типа void указывает, что значение недоступно.

Производные типы

К ним относятся (а) типы указателей, (б) типы массивов, (в) типы структур, (г) типы объединений и (д) типы функций.

Типы массивов и типы структур вместе называются агрегатными типами. Тип функции определяет тип возвращаемого функцией значения. Мы рассмотрим основные типы в следующем разделе, а другие типы будут рассмотрены в следующих главах.

Целые типы

В следующей таблице приведены подробные сведения о стандартных целочисленных типах с размерами их хранилищ и диапазонами значений —

< td>unsigned int
Тип Размер хранилища Диапазон значений
char 1 байт -128 до 127 или от 0 до 255
беззнаковый символ 1 байт от 0 до 255
символ со знаком 1 байт -128 до 127
int 2 или 4 байта -32 768 до 32 767 или от -2 147 483 648 до 2 147 483 647
2 или 4 байта от 0 до 65 535 или от 0 до 4 294 967 295
short 2 байта -32 768 до 32 767
короткое без знака 2 байта 0 до 65 535< /td>
long 8 байт или (4 байта для 32-разрядной ОС) -9223372036854775808 до 9223372036854775807
длинный без знака 8 байт от 0 до 18446744073709551615
< /p>

Чтобы получить точный размер типа или переменной на определенной платформе, вы можете использовать оператор sizeof. Выражения sizeof(type) дают размер хранения объекта или типа в байтах. Ниже приведен пример получения размера различного типа на машине с использованием другой константы, определенной в заголовочном файле limit.h —

Когда вы скомпилируете и запустите приведенную выше программу, она выдаст следующий результат в Linux —

Типы с плавающей запятой

В следующей таблице приведены подробные сведения о стандартных типах с плавающей запятой с размерами хранилища и диапазонами значений, а также их точностью —

Тип Размер хранилища Диапазон значений Точность
float 4 байта от 1.2E-38 до 3.4E+38 6 знаков после запятой
двойное число 8 байт от 2.3E-308 до 1.7E+308 15 знаков после запятой
long double 10 byte< /td> от 3.4E-4932 до 1.1E+4932 19 знаков после запятой

Заголовочный файл float.h определяет макросы, позволяющие использовать эти значения и другие сведения о двоичном представлении действительных чисел в ваших программах. В следующем примере выводится место для хранения, занятое типом с плавающей запятой, и его значения диапазона —

Когда вы скомпилируете и запустите приведенную выше программу, она выдаст следующий результат в Linux —

Тип void

Тип void указывает, что значение недоступно. Он используется в трех видах ситуаций —

Функция возвращает значение void

В C есть различные функции, которые не возвращают никакого значения или, можно сказать, возвращают void. Функция без возвращаемого значения имеет возвращаемый тип void. Например, void exit (int status);

Аргументы функции недействительны

В C есть различные функции, которые не принимают никаких параметров. Функция без параметра может принимать пустое значение. Например, int rand(void);

Указатели на void

Указатель типа void * представляет адрес объекта, но не его тип. Например, функция выделения памяти void *malloc( size_t size ); возвращает указатель на void, который можно привести к любому типу данных.

Читайте также: