Почему int 4 байта
Перейти к содержимому

Почему int 4 байта

Почему C++ int и long типы оба 4 байта?

многие источники, в том числе Microsoft, как int и Long тип как 4 байта и имеющий диапазон (подпись) -2,147,483,648 до 2,147,483,647. Какой смысл иметь длинный примитивный тип, если он фактически не предоставляет больший диапазон значений?

8 ответов

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

  1. sizeof(char) == 1
  2. sizeof(char) <= sizeof(short)
  3. sizeof(short) <= sizeof(int)
  4. sizeof(int) <= sizeof(long)
  5. sizeof(long) <= sizeof(long long)
  6. sizeof(char) * CHAR_BIT >= 8
  7. sizeof(short) * CHAR_BIT >= 16
  8. sizeof(int) * CHAR_BIT >= 16
  9. sizeof(long) * CHAR_BIT >= 32
  10. sizeof(long long) * CHAR_BIT >= 64

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

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

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

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

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

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

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

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

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

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

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

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

стандарт C/C++ определяется как описанные Griwes. Это позволяет реализовать язык C и C++, где поставщик компилятора может определить размеры, наиболее удобные для архитектуры компьютера. Некоторое время (для Windows 3.1 и ранее, то есть до Windows 95) код C для windows имел 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 биты доступны долго.

Почему типы C ++ int и long имеют 4 байта?

Многие источники, включая Microsoft , ссылаются на тип int и long как на 4 байта и имеющий диапазон (подписанный) от -2 147 483 648 до 2 147 483 647. Какой смысл в длинном примитивном типе, если он на самом деле не обеспечивает более широкий диапазон значений?

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

  1. sizeof(char) == 1
  2. sizeof(char) <= sizeof(short)
  3. sizeof(short) <= sizeof(int)
  4. sizeof(int) <= sizeof(long)
  5. sizeof(long) <= sizeof(long long)
  6. sizeof(char) * CHAR_BIT >= 8
  7. sizeof(short) * CHAR_BIT >= 16
  8. sizeof(int) * CHAR_BIT >= 16
  9. sizeof(long) * CHAR_BIT >= 32
  10. sizeof(long long) * CHAR_BIT >= 64

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

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

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

Краткое резюме, 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 семьи, чтобы заставить постоянный размер, если он действительно не нужен.

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

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

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

13 ответов

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

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

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

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

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

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

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

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

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

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

Стандартный черновик C99 N1256

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

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

5.2.4.2.1 «Размеры целочисленных типов <limits.h> » указывают минимальные размеры:

  • 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 «Булевы значения, символы и целые числа» определяют относительные ранги преобразования:

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

Занимает ли целочисленная переменная в C 2 байта или 4 байта?

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

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

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

sizeof , байт и CHAR_BIT

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

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

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

На этом пока завершим:

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

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

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

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

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

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

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

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

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

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

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

Размер 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 в том, что можно написать эффективную программу для такой платформы, и даже сделать это переносимым способом!

Добавить комментарий

Ваш адрес email не будет опубликован.