Является ли размер C "int" 2 байта или 4 байта?

Ответ 1

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

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

РЕДАКТИРОВАТЬ: Исправлен неверный оператор, который int равен 8 байтам для большинства 64-разрядных систем. Например, это 4 байта в 64-битном GCC.

Ответ 2

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

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

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

Ответ 3

Нет конкретного ответа. Это зависит от платформы. Он определяется реализацией. Это может быть 2, 4 или что-то еще.

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

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

Ответ 4

Ответ на этот вопрос зависит от того, какую платформу вы используете.
Но независимо от платформы вы можете надежно использовать следующие типы:

 [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

Ответ 5

Переменная Integer в C занимает 2 байта или 4 байта?

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

На каких факторах это зависит?

Дальность может быть лучше всего рассмотрена, а не размер. Оба варианта будут меняться на практике, хотя гораздо более безупречно выбирать типы переменных по диапазону, чем размер, как мы увидим. Также важно отметить, что стандарт поощряет нас рассматривать выбор наших целочисленных типов на основе диапазона, а не размера, но на данный момент можно игнорировать стандартную практику, и пусть наше любопытство исследует sizeof, bytes и CHAR_BIT и целочисленное представление... let прорежьте кроличью нору и посмотрите на нее...

sizeof, bytes и CHAR_BIT

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

Оператор sizeof дает размер (в байтах) своего операнда, который может быть выражением или именем в скобках типа. Размер определяется по типу операнда.

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

Пусть оберните все до сих пор:

• sizeof => размер в байтах и
• CHAR_BIT => количество бит в байте

Таким образом, в зависимости от вашей системы sizeof (unsigned int) может быть любым значением больше нуля (не только 2 или 4), как если бы CHAR_BIT равно 16, тогда один (шестнадцатибитный) байт имеет в нем достаточно бит, чтобы представлять шестнадцатибитное целое число, описанное стандартами (приведено ниже). Это не обязательно полезная информация, не так ли? Позвольте углубиться глубже...

Целочисленное представление

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

UINT_MAX                                65535 // 2¹⁶ - 1

Таким образом, мы можем видеть, что unsigned int требует (по крайней мере) 16 бит, где вы получаете два байта (при условии, что CHAR_BIT равно 8)... и позже, когда этот предел увеличился до 2³² - 1, люди указали вместо этого 4 байта. Этим объясняются явления, которые вы наблюдали:

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

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

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

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

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

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

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

Ответ 6

C99 N1256 стандартная тяга

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

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

• минимальный размер гарантии
• относительные размеры между типами

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

1 [...] их значения, определенные реализацией, должны быть равны или больше по величине (абсолютное значение) показанным [...]

• 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 Для любых двух целочисленных типов с одинаковыми знаками и разным целочисленным рангом преобразования (см. 6.3.1.1) диапазон значений типа с меньшим целочисленным рангом преобразования является поддиапазоном значений другого типа.

и 6.3.1.1 "Булевы, символы и целые числа" определяют относительные ранги преобразования:

1 Каждый целочисленный тип имеет ранг целочисленного преобразования, определенный следующим образом:

• Ранг long long int должен быть больше ранга long int, который должен быть больше ранга int, который должен быть больше ранга short int, который должен быть больше ранга подписанного символа char.
• Ранг любого целого типа без знака должен равняться рангу соответствующего целого типа со знаком, если таковой имеется.
• Для всех целочисленных типов T1, T2 и T3, если T1 имеет больший ранг, чем T2, и T2 имеет больший ранг, чем T3, то T1 имеет больший ранг, чем T3

Ответ 7

Единственные гарантии заключаются в том, что char должен иметь ширину не менее 8 бит, short и int должен иметь ширину не менее 16 бит, а long должен быть не менее 32 бит в ширину, а sizeof (char) <= sizeof (short) <= sizeof (int) <= sizeof (long) (то же самое верно для неподписанных версий этих типов).

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

Ответ 8

В основном это зависит от используемой вами платформы. Это зависит от компилятора от компилятора. В настоящее время в большинстве компиляторов int составляет 4 байта. Если вы хотите проверить, что использует ваш компилятор, вы можете использовать sizeof(int).

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

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

Ответ 9

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

Ответ "да"/"нет"/"возможно"/"возможно нет".

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

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

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

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

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

Ответ 10

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

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

Ответ 11

#include <stdio.h>

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

Это возвращает 4, но, вероятно, зависит от машины.

Ответ 12

Эта программа может объяснить основную разницу между командами времени компиляции и инструкцией времени выполнения в программировании на языке С

Вот код:

#include <stdio.h>
main()
{
    int a = 10,b;
    b= sizeof(a++); // b holds total number of bytes occupied in memory by  a
    printf("\n %d %d \n", a,b);
}

Ожидаемый результат должен быть: a = 11, b = 4
(b содержит общее количество байтов, занятых в памяти, a)

вывод:

gcc example.c -o example

./example

10 4

C можно разделить на два типа:

• Инструкции времени компиляции
• Инструкции по времени выполнения

Команды времени компиляции - это те инструкции, которые выполняются во время компиляции.

Инструкции по времени выполнения - это те команды, которые выполняются во время выполнения

Большинство разработчиков не знают, какие команды попадают во время компиляции и какие инструкции попадают во время выполнения.

Здесь sizeof - это оператор времени компиляции, но ++ - оператор времени выполнения. поэтому ++ - это оператор, который будет выполняться CPU, а sizeof - это ключевое слово, которое будет выполняться компилятором во время компиляции.

когда компилятор встретил такой оператор b= sizeof(a++), он просто заменяет результат выражения. результат выражения будет возвращать значение sizeof. Когда исполняемый файл сгенерирован, b будет удерживать значение 4. Поэтому инструкции a++ удаляются компилятор. потому что sizeof - это команда времени компиляции, и она будет выполнена. Теперь попробуйте перезаписать код

#include <stdio.h>
main()
{
    int a = 10,b;
    b = sizeof(a);
    a++;
    printf("\n %d %d \n", a,b);
}

gcc example.c -o example

./example

11 4

Мы не можем ожидать, что все инструкции будут выполняться процессором.

Ответ 13

Является ли размер C "int" 2 байта или 4 байта?

Переменная Integer в C занимает 2 байта или 4 байта?

C позволяет "байтам" быть чем-то иным, чем 8 бит на "байт".

CHAR_BIT количество бит для наименьшего объекта, который не является битовым полем (байтом) C11dr §5.2.4.2.1 1

Значение чего-то, чем 8, становится все более необычным. Для максимальной переносимости используйте CHAR_BIT а не 8. Размер int в битах в C равен sizeof(int) * CHAR_BIT.

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

На каких факторах это зависит?

Размер бита int обычно составляет 32 или 16 бит. C заданные минимальные диапазоны:

минимальное значение для объекта типа int INT_MIN -32767
максимальное значение для объекта типа int INT_MAX +32767
C11dr §5.2.4.2.1 1

Минимальный диапазон для int заставляет размер бита быть не менее 16 - даже если процессор был "8 бит". Размер таких процессоров, как 64 бит, наблюдается в специализированных процессорах. Другие ценности, такие как 18, 24, 36 и т.д., Произошли на исторических платформах или, по крайней мере, теоретически возможны. Современное кодирование редко волнуется Неэнергетических-офом-2 int битных размеров.

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

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

Ответ 14

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

Но этот вопрос является своего рода всегда правдой, а "Да, и то, и другое".

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

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

Если вы объявляете int t[12];, он вернет 12 * 4 байта. Чтобы получить длину этого массива, просто используйте sizeof(t)/sizeof(t[0]). Если вы собираетесь создать функцию, которая должна рассчитать размер массива send, помните, что если

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) и определите функцию2 (массив t, int size_of_t). Вызвать "function (t)" измерять длину с помощью некоторой копии и отправлять результат в функцию2, где вы можете делать все, что хотите, при переменных размерах массива.

Ответ 15

Его 4 байта, в зависимости от процессора. Он может использовать long для 8 байтов, но если процессор имеет 32 байтовых слова, чем 32 байта.