Размер C «int» 2 байта или 4 байта?

Переменная Integer в C занимает 2 байта или 4 байта? От каких факторов это зависит?

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

 netcoder11 июл. 2012 г., 21:35
Пытаться#define int int64_t на 64-битной платформе, так что нет. Просто используйтеsizeof. ;-)
 phuclv01 июл. 2016 г., 08:01
 Evan Mulawski11 июл. 2012 г., 20:15
 Keith Thompson11 июл. 2012 г., 20:22
И вы должны найти лучшие учебники. Учебник, который говоритint is 2 bytes (a), вероятно, относится к старой системе, и (b) не в состоянии прояснить, что размер будет варьироваться от одной системы к другой. Лучшая книга по Си - это «Язык программирования Си». Керниганом и Ричи, хотя это предполагает некоторый опыт программирования. Смотрите также вопрос 18.10comp.lang.c FAQ.
 Keith Thompson11 июл. 2012 г., 20:18
int это только один из несколькихinteger типы. Вы спросили о размере "целое число"; Вы, вероятно, хотели спросить о размереint.

Ответы на вопрос(13)

Does an Integer variable in C occupy 2 bytes or 4 bytes?

C допускает "байты" быть чем-то отличным от 8 бит на «байт».

CHAR_BIT number of bits for smallest object that is not a bit-field (byte) C11dr §5.2.4.2.1 1

Значение, превышающее 8, становится все более редким. Для максимальной мобильности используйтеCHAR_BIT а не 8. Размерint вbits  в сsizeof(int) * CHAR_BIT.

#include <limits.h>
printf("(int) Bit size %zu\n", sizeof(int) * CHAR_BIT);

What are the factors that it depends on?

int размер бита обычно составляет 32 или 16 бит. С указанным минимумомranges:

minimum value for an object of type int INT_MIN -32767
maximum value for an object of type int INT_MAX +32767
C11dr §5.2.4.2.1 1

minimum range заint заставляет размер бита бытьat least 16 - даже если процессор был «8-битным». Размер как 64 бита замечен в специализированных процессорах. Другие значения, такие как 18, 24, 36 и т. Д., Встречались на исторических платформах или, по крайней мере, теоретически возможны. Современное кодирование редко беспокоит не-власть-2int битовые размеры.

Процессор и архитектура компьютера управляютint выбор размера бита.

Но даже с 64-битными процессорами компиляторint размер может быть 32-битным по соображениям совместимости, поскольку большие базы кода зависят отint будучи 32-битным (или 32/16).

которую вы используете. Это зависит от компилятора до компилятора. В настоящее время в большинстве компиляторовint имеет4 bytes. If you want to check what your compiler is using you can use sizeof(int).

main()
{
    printf("%d",sizeof(int));
    printf("%d",sizeof(short));
    printf("%d",sizeof(long));
}

Единственное, что обещает компилятор c, это то, что размер short должен быть равен или меньше, чем int, а размер long должен быть равен или больше, чем int. Так что, если размер int равен 4, то размер short может быть 2 или 4, но не больше. чем это. То же самое верно для долго и инт. Это также говорит о том, что размер короткого и длинного не может быть одинаковым.

 27 июн. 2017 г., 18:38
С помощью%d дляsize_t параметр UB.
#include <stdio.h>

int main(void) {
    printf("size of int: %d", (int)sizeof(int));
    return 0;
}

sizeof(int), Размерint действительно зависит от компилятора. В те времена, когда процессоры были 16-битными,int было 2 байта. В настоящее время это чаще всего 4 байта как в 32-разрядных, так и в 64-разрядных системах.

Тем не менее, используяsizeof(int) это лучший способ получить размер целого числа для конкретной системы, на которой выполняется программа.

EDIT: Исправлено неверное утверждение, чтоint 8 байт в большинстве 64-битных систем. Например, это 4 байта на 64-битном GCC.

 11 июл. 2012 г., 20:20
@ RajivPrathap: Ну, это зависит от компилятора, но компилятор решает, является ли он также машинно-зависимым. :)
 20 июл. 2015 г., 16:53
неправильно. на большинстве 64-битных систем int все еще 4 байтаen.wikipedia.org/wiki/64-bit_computing#64-bit_data_models
 10 янв. 2015 г., 20:05
Это зависит не только от машины, но и от операционной системы, работающей на машине. Например, long в Win64 составляет 4 байта, тогда как long в Linux64 составляет 8 байтов.
 15 апр. 2014 г., 19:10
Если вам нужен размер для препроцессора, вы можете проверить предопределенные макросы, такие как INT_MAX. Если значение не соответствует ожидаемому в вашем коде, тогда размер байта int отличается в текущей комбинации компилятор / платформа.
 27 июн. 2017 г., 19:20
sizeof(int) может быть любым значением из1, Байт не обязательно должен быть 8 битами, и некоторые машины не имеют 8-битной адресуемой единицы (которая в основном является определениемbyte в стандарте). Ответ не верен без дополнительной информации.

C99 N1256 standard draft

http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf

Размерint и все другие целочисленные типы определены реализацией, C99 определяет только:

minimum size guarantees relative sizes between the types

5.2.4.2.1 "Размеры целочисленных типов<limits.h>& Quot; дает минимальные размеры:

1 [...] Their implementation-defined values shall be equal or greater in magnitude (absolute value) to those shown [...]

UCHAR_MAX 255 // 2 8 − 1 USHRT_MAX 65535 // 2 16 − 1 UINT_MAX 65535 // 2 16 − 1 ULONG_MAX 4294967295 // 2 32 − 1 ULLONG_MAX 18446744073709551615 // 2 64 − 1

6.2.5 «Типы» затем говорит:

8 For any two integer types with the same signedness and different integer conversion rank (see 6.3.1.1), the range of values of the type with smaller integer conversion rank is a subrange of the values of the other type.

и 6.3.1.1 «логические, символы и целые числа»; определяет относительные конверсионные ранги:

1 Every integer type has an integer conversion rank defined as follows:

The rank of long long int shall be greater than the rank of long int, which shall be greater than the rank of int, which shall be greater than the rank of short int, which shall be greater than the rank of signed char. The rank of any unsigned integer type shall equal the rank of the corresponding signed integer type, if any. For all integer types T1, T2, and T3, if T1 has greater rank than T2 and T2 has greater rank than T3, then T1 has greater rank than T3

char должно бытьat least 8 бит шириной,short а такжеint должно бытьat least 16 бит в ширину иlong должно бытьat least 32 бит в ширину, и этоsizeof (char) & Л; =sizeof (short) & Л; =sizeof (int) & Л; =sizeof (long) (то же самое верно для неподписанных версий этих типов).

int может иметь ширину от 16 до 64 бит в зависимости от платформы.

который может сначала сбить с толку, но стандарт C определяет толькоminimum range для целочисленных типов, которые гарантированно поддерживаются.int гарантированно может содержать от -32767 до 32767, что требует 16 бит. В таком случае,int2 байта. Однако реализации могут выйти за пределы этого минимума, как вы увидите, что многие современные компиляторы делаютint 32-разрядный (что также означает 4 байта довольно повсеместно).

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

Чтобы решить эту проблему, C99 добавил новые типы, где вы можете явно запросить целое число определенного размера, напримерint16_t или жеint32_t, До этого не было универсального способа получить целое число определенной ширины (хотя большинство платформ предоставляло схожие типы для каждой платформы).

 07 июл. 2013 г., 15:24
+1 для int16_t и int32_t
 16 июл. 2014 г., 23:08
@RSerrao Я тоже не эксперт C, но AFAIK для положительных чисел на единицу меньше максимального отрицательного числа. Итак, от -8 до 7, от -256 до 255 и так далее. Отрицательные числа не должны считать ноль.
 26 мар. 2014 г., 23:16
@nevanking: на машине с двумя дополнительными устройствами (каждая машина, о которой я знаю ...), да. Но C не гарантирует, что это так.
 27 июн. 2017 г., 19:00
@nevanking: только если вы предполагаете, что 2 представления дополняют подписанноеint, С не делает этого предположения. 1 'системы дополнения и величины знака не могут представлять-32768 в 16 битах; скорее, они имеют два представления для нуля (положительное и отрицательное). Вот почему минимальный диапазон дляint является[-32767..32767].
 03 мар. 2017 г., 15:55
"16 бит. В этом случае int составляет 2 байта & quot; может быть неправильным, если CHAR_BIT равен 16, sizeof (int) может быть 1 байт (или символ).

Это хороший источник для ответа на этот вопрос.

Но этот вопрос является своего рода всегда правдой и отвечает "Да". . Оба & Quot;

Это зависит от вашей архитектуры. Если вы собираетесь работать на 16-битном компьютере или менее, он не может быть 4 байта (= 32 бита). Если вы работаете на 32-битной или более качественной машине, ее длина составляет 32-битную.

Чтобы выяснить, подготовите ли вы программу для вывода чего-то читаемого и используйте & quot; sizeof & quot; функция. Это возвращает размер в байтах вашего объявленного типа данных. Но будьте осторожны, используя это с массивами.

Если вы декларируетеint t[12]; он вернет 12 * 4 байта. Чтобы получить длину этого массива, просто используйтеsizeof(t)/sizeof(t[0]). If you are going to build up a function, that should calculate the size of a send array, remember that if

typedef int array[12];
int function(array t){
    int size_of_t = sizeof(t)/sizeof(t[0]);
    return size_of_t;
}
void main(){
    array t = {1,1,1};  //remember: t= [1,1,1,0,...,0]
    int a = function(t);    //remember: sending t is just a pointer and equal to int* t
   print(a);   // output will be 1, since t will be interpreted as an int itselve. 
}

Так что это даже не вернет что-то другое. Если вы определяете массив и пытаетесь получить длину впоследствии, используйте sizeof. Если вы отправляете массив в функцию, помните, что значение send это просто указатель на первый элемент. Но в первом случае вы всегда знаете, какой размер имеет ваш массив. Случай два можно выяснить, определив две функции и упустив некоторые характеристики. Определите функцию (массив t) и определите function2 (массив t, int size_of_t). Вызовите «функцию (t)» измерьте длину некоторой копировальной работой и отправьте результат в function2, где вы можете делать что угодно с переменными размерами массива.

Ответ "да" / & quot; нет & quot; / & quot; возможно & quot; / "возможно, нет".

Язык программирования C определяет следующее: наименьшая адресуемая единица, известнаяchar а также называется"byte"ТочноCHAR_BIT биты шириной, гдеCHAR_BIT по крайней мере 8.

Так чтоbyte в C не обязательноoctetто есть 8 бит. В прошлом одна из первых платформ для запуска кода C (и Unix) имела 4-байтовый код.int - но всегоint было 36 бит, потому чтоCHAR_BIT было 9!

int должен быть естественным целочисленным размером для платформы, которая имеет диапазонat least -32767 ... 32767, Вы можете получить размерint в байтах платформы сsizeof(int); когда вы умножаете это значение наCHAR_BIT Вы будете знать, как широко он в битах.

Хотя 36-битные машины в основном не работают, все еще существуют платформы с не 8-битными байтами. Только вчера там быловопрос про Texas Instruments MCU с 16-битными байтами, который имеет C99, C11-совместимый компилятор.

НаTMS320C28x Кажется, чтоchar, short а такжеint являютсяall 16 бит в ширину и, следовательно, один байт.long int 2 байта иlong long int 4 байта. Прелесть C в том, что все еще можно написать эффективную программу для такой платформы и даже сделать это портативным способом!

реализацией. Это может быть 2, 4 или что-то еще.

Идея позадиint было то, что он должен был соответствовать натуральному «слову» Размер для данной платформы: 16 бит на 16-битных платформах, 32 бит на 32-битных платформах, 64 бит на 64-битных платформах, вы поняли идею. Однако в целях обратной совместимости некоторые компиляторы предпочитают придерживаться 32-битныхint даже на 64-битных платформах.

Время 2 байтаint хотя давно прошло (16-битные платформы?), если вы не используете какую-то встроенную платформу с 16-битным размером слова. Ваши учебники, вероятно, очень старые.

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

Если вы хотите убедиться, что вы используете тип определенного размера, используйте типы в<stdint.h>


Но независимо от платформы вы можете надежно предположить следующие типы:

 [8-bit] signed char: -127 to 127
 [8-bit] unsigned char: 0 to 255
 [16-bit]signed short: -32767 to 32767
 [16-bit]unsigned short: 0 to 65535
 [32-bit]signed long: -2147483647 to 2147483647
 [32-bit]unsigned long: 0 to 4294967295
 [64-bit]signed long long: -9223372036854775807 to 9223372036854775807
 [64-bit]unsigned long long: 0 to 18446744073709551615
 09 нояб. 2018 г., 09:01
@CodyGray это колеблется взад и вперед, будучи совместимым с 1 'дополнением в течение последних 3 лет, и OP ничего не сказал, поэтому я отменил редактирование, которое изменило его на 2' дополнение с "Fix range", так как оно говорит "quot" Вы можете достоверно предположить & quot ;, что все еще не совсем верно.
 09 нояб. 2018 г., 08:56
@ k06ayour edit was incorrect, Вы специально изменили исходные диапазоны на диапазоны с 2 комплементами - этоnot те, которые указаны в стандарте C.
 08 авг. 2014 г., 16:42
Кто-то отредактировал ваше сообщение как "исправить" диапазоны, но я не уверен, что ваша правка адекватно отражает ваши намерения. Предполагается реализация в два дополнения, что будет верно вmost случаи, но не все. Поскольку ваш ответ конкретно указывает на зависимость от реализации, я думаю, что редактирование, вероятно, является неправильным. Если вы согласны, пожалуйста, не забудьте отредактировать.

Это зависит от платформы, которую вы используете, а также от того, как настроен ваш компилятор. Единственный авторитетный ответ - использоватьsizeof Оператор, чтобы увидеть, насколько большое целое число в вашей конкретной ситуации.

What are the factors that it depends on?

Range может быть лучше, чемsize, На практике оба варианта будут различаться, хотя гораздо более надежно выбирать типы переменных по диапазону, чем по размеру, как мы увидим. Также важно отметить, что стандарт побуждает нас рассмотреть возможность выбора целочисленных типов на основеrange скорее, чемsize, но пока давайтеignore the standard practiceи пусть наше любопытство исследуетsizeof, байтов иCHAR_BITи целочисленное представление ... давайте прорвемся в кроличью нору и увидим это сами ...

sizeof, bytes and CHAR_BIT

Следующее утверждение, взятое из стандарта C (связанного с вышеупомянутым), описывает это словами, которые, я думаю, не могут быть улучшены.

The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type. The size is determined from the type of the operand.

Предполагая, что ясное понимание приведет нас к дискуссии оbytes, Обычно предполагается, чтоbyte восемь бит, когда на самом делеCHAR_BIT tells you how many bits are in a byte, Это просто еще один из тех нюансов, который не учитывается при разговоре оthe common two (or four) byte integers.

Давайте подведем итоги:

sizeof => size in bytes, and CHAR_BIT => number of bits in byte

Таким образом, в зависимости от вашей системы,sizeof (unsigned int) может бытьany значение больше нуля (не только 2 или 4), как будтоCHAR_BIT тогда 16a single (sixteen-bit) byte в нем достаточно битов для представления шестнадцати разрядного целого числа, описанного в стандартах (приведенных ниже). Это не обязательно полезная информация, не так ли? Давайте углубимся ...

Integer representation

Стандарт C определяет минимальную точность / диапазон для всех стандартных целочисленных типов (иCHAR_BITтоже молодец)Вот, Из этого мы можем извлечьa minimum сколько бит требуется для храненияthe value, но мы также можем просто выбрать наши переменные на основеranges, Тем не менее, огромная часть деталей, необходимых для этого ответа, находится здесь. Например, следующее, что стандартunsigned int требуется (как минимум) шестнадцать бит хранения:

UINT_MAX                                65535 // 2¹⁶ - 1

Thus we can see that unsigned int require (at least) 16 bits, где вы получаетеtwo bytes (при условии,CHAR_BIT 8) ... и позже, когда этот предел увеличился до2³² - 1вместо этого люди указали 4 байта. Это объясняет явления, которые вы наблюдали:

Most of the textbooks say integer variables occupy 2 bytes. But when I run a program printing the successive addresses of an array of integers it shows the difference of 4.

Вы используете древний учебник и компилятор, который учит вас непереносимым C; автор, написавший ваш учебник, может даже не знать оCHAR_BIT, Выshould обновите свой учебник (и компилятор) и постарайтесь запомнить, что И.Т. это постоянно развивающаяся область, в которой вам нужно остатьсяahead of конкурировать ... Впрочем, хватит об этом; давайте посмотрим, какие другие непереносимые секреты этиunderlying integer bytes хранить...

Value bits это то, что распространенные заблуждения, кажется, считают. В приведенном выше примере используетсяunsigned целочисленный тип, который обычно содержит только биты значения, так что в деталях легко пропустить дьявола.

Sign bits... В приведенном выше примере я процитировалUINT_MAX как верхний предел дляunsigned int потому что это тривиальный пример для извлечения значения16 из комментария. Для типов со знаком, чтобы различать положительные и отрицательные значения (это знак), мы также должны включать бит знака.

INT_MIN                                -32768 // -(2¹⁵)
INT_MAX                                +32767 // 2¹⁵ - 1

Padding bits... Хотя нередко встречаются компьютеры с битами заполнения в целых числах, стандарт C допускает это; некоторые машины (т.е.этот) реализовать большие целочисленные типы путем объединения двух меньших (знаковых) целочисленных значений вместе ... и когда вы объединяете целые числа со знаком, вы получаете потерянный знаковый бит. Это впустую считаетсяpadding в C. Другие примеры битов заполнения могут включать в себябиты четности и биты ловушки.

Как вы можете видеть, стандарт, кажется, поощряет рассмотрение таких диапазонов, какINT_MIN..INT_MAX а такжедругие минимальные / максимальные значения из стандарта при выборе целочисленных типов иdiscourages полагаться на размеры, поскольку есть другие тонкие факторы, которые могут быть забыты, такие какCHAR_BIT и биты заполнения, которые могут повлиять на значениеsizeof (int) (то есть распространенные заблужденияtwo-byte and four-byte integers пренебрегает этими деталями).

Ваш ответ на вопрос