Почему С++ int и длинные типы - 4 байта?

Ответ 1

Единственное, что гарантируется для целочисленных типов:

• sizeof(char) == 1
• sizeof(char) <= sizeof(short)
• sizeof(short) <= sizeof(int)
• sizeof(int) <= sizeof(long)
• sizeof(long) <= sizeof(long long)
• sizeof(char) * CHAR_BIT >= 8
• sizeof(short) * CHAR_BIT >= 16
• sizeof(int) * CHAR_BIT >= 16
• sizeof(long) * CHAR_BIT >= 32
• sizeof(long long) * CHAR_BIT >= 64

Другими вещами являются реализация. Благодаря (4) оба long и int могут иметь одинаковый размер, но должны быть не менее 32 бит (благодаря (9)).

Ответ 2

Стандарт С++ указывает только, что long по крайней мере такой же большой, как int, поэтому в сценарии нет ничего криминального, когда он такой же большой: он полностью определен в реализации. На разных платформах размеры могут иметь значение, например, я имею int размером 4 и long размера 8 в настоящий момент на моей машине Linux.

Ответ 3

Как указывали другие, предположение, лежащее в основе вопроса, является лишь частично истинным, т.е. не выполняется для некоторых платформ. Если вы действительно хотите понять, как мы пришли к текущей ситуации, Long Road to 64 Bits" Дж. Машей даст вам хороший обзор различные силы в присутствии и как они взаимодействовали.

Краткая сводка, C начинается с char (8 бит) и int (16 бит). Затем добавлен short (16 бит) и long (32 бит), тогда как int может быть 16 или 32 бита в зависимости от того, что было естественным на платформе, и давления обратной совместимости. Когда пришло 64 бита, long long был добавлен как 64-битный тип, и были некоторые корректировки в меньших типах на 64-битных платформах. Вещи, стабилизированные 32 битами int, но long содержали различные определения, некоторые 64-разрядные платформы имели 64 бита long, в то время как другие (возможно, только Windows?) Хранили long до 32 бит, вероятно, из-за разных (Unix долгое время предполагала, что long имеет тот же размер, что и указатель, Windows имела больше остатков в своем API того времени, когда int составлял 16 бит, и, таким образом, long был единственным 32 битом тип). BTW typedefs (intXX_t, intptr_t) были добавлены, чтобы помочь сделать намерение более ясным, рискуя тем, что семейство intXX_t вынуждает постоянный размер, действительно, не нужны.

Ответ 4

Нет, это только 4 байта на некоторых платформах. Стандарт С++ оставляет размер как определяемый реализацией.

На других платформах это может быть другого размера.

Ответ 5

Это не обязательно должно быть больше. Это как раз то, что GCC, например, обычно имеет long для определения 8 байтов, когда я использовал его на своей машине. Стандартная формулировка обычно говорит, что эти типы "должны быть как минимум X размера" (например, проверьте окончательно стандартизованный long long в С++ 11.

По сути, любой человек может делать то, что хочет, если он соответствует требованиям. Согласно стандарту, кто-то может сделать long long 256 бит, и это будет совершенно законно.

Ответ 6

Спецификация языка С++ просто указывает, что размер long должен быть, по крайней мере, размером int.

Он был стандартным для int= 2 байта и long= 4 байта. По какой-то причине int вырос, а long остался прежним (по крайней мере на компиляторах Windows). Я могу только предположить, что long хранился один и тот же по соображениям обратной совместимости...

Ответ 7

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

Ответ 8

Никто не ответил на ваш реальный вопрос, кроме, возможно, AProgrammer.

Стандарт C/С++ определяется как описано Griwes. Это позволяет реализовать язык C и С++, где поставщик компилятора может определить размеры, наиболее удобные для компьютерной архитектуры. Некоторое время (для Windows 3.1 и раньше, то есть до Windows 95), код C для окон имел 16-битный int, тогда как многие платформы UNIX, такие как Solaris, HPUX и AIX, имели 32-битный int.

Однако современные микрокомпьютеры (начиная с 386) имеют полные 32-битные регистры, а адресная память, совмещенная с 32 битами, намного быстрее, чем доступ к 16-битным приращениям. Таким образом, код намного эффективнее с 32-битным int, особенно для массивов int, чем это может быть с 16-битным int.

Чтобы имитировать 16-битный int в 32-битном регистре, вы также должны переполняться на 16-м бите вместо 32-го. Таким образом, это просто проще с 32-битным int, даже если у вас есть только 32 бита в течение долгого времени.