Размер int c: C++ | Типы данных

Вся правда о целочисленных типах в C / Хабр

Для начала несколько вопросов:

  1. Тип char по умолчанию знаковый или нет? А int?
  2. Законно ли неявное приведение (signed char *) к (char *)? А то же для int?
  3. Сколько бит в unsigned char?
  4. Какое максимальное число гарантированно можно поместить в int? А минимальное?
  5. Тип long определённо больше, чем char, не так ли?

Разумеется, экспериментально искать ответы на эти вопросы с помощью вашего любимого компилятора в вашей любимой системе на вашем любимом компьютере

1)

— не лучшая идея. Мы говорим о стандарте языка (С99 и новее).

Если вы уверенно сможете правильно ответить на эти вопросы, тогда эта статья не для вас. В противном случае десять минут, потраченные на её чтение, будут весьма полезны.

Предположу, что вы ответили
  1. Знаковые оба.
  2. Законны оба.
  3. 8.
  4. 2147483647. -214748364
    8
    .
  5. Конечно, Кэп.


А правильные ответы такие
  1. char — не регламентируется, int — знаковый.
  2. Для int — законно, а для char — нет.
  3. Не менее 8.
  4. 32767. -32767
  5. Вообще говоря, нет.

Про signed и unsigned

Все целочисленные типы кроме

char

, по умолчанию знаковые (signed).

С char ситуация сложнее. Стандарт устанавливает три различных типа: char, signed char, unsigned char. В частности, указатель типа (signed char *) не может быть неявно приведён к типу (char *).

Хотя формально это три разных типа, но фактически char эквивалентен либо signed char, либо unsigned char

— на выбор компилятора (стандарт ничего конкретного не требует).

Подробнее про char я написал в комментариях.

О размере unsigned char

Тип

unsigned char

является абстракцией машинного байта. Важность этого типа проявляется в том, что С может адресовать память только с точностью до байта. На большинстве архитектур размер байта равен 8 бит, но бывают и исключения. Например, процессоры с 36-битной архитектурой как правило имеют 9-битный байт, а в некоторых DSP от Texas Instruments байты состоят из 16 или 32 бит. Древние архитектуры могут иметь короткие байты из 4, 5 или 7 бит.

Стандарт С вынужден отказаться от допотопных архитектур и требует, чтобы байты были как минимум 8-битные. Конкретное значение (CHAR_BIT

2)) для данной платформы записано в заголовочном файле limits.h.

Размеры целочисленных типов в С

C переносимый, поэтому в нём базовые целочисленные типы (

char

,

short

,

int

и др. ) не имеют строго установленного размера, а зависят от платформы. Однако эти типы не были бы переносимы, если бы

их размеры были совершенно произвольные: стандарт устанавливает

минимальные диапазоны

принимаемых значений для всех базовых целочисленные типов. А именно,

  • signed char: -127…127 (не -128…127; аналогично другие типы)
  • unsigned char
    : 0…255 (= 28−1)
  • signed short: -32767…32767
  • unsigned short: 0…65535 (= 216−1)
  • signed int: -32767…32767
  • unsigned int: 0…65535 (= 216−1)
  • signed long: -2147483647…2147483647
  • unsigned long: 0…4294967295 (= 232−1)
  • signed long long: -9223372036854775807…9223372036854775807
  • unsigned long long: 0…18446744073709551615 (= 264−1)

Стандарт требует, чтобы максимальное значение

unsigned char

было 2

CHAR_BIT

−1 (см.

предыдущий пункт).

Стандарт требует sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long). Таким образом, вполне законны ситуации типа sizeof(char)=sizeof(long)=32. Для некоторых DSP от Texas Instruments так и есть.

Конкретные значения этих диапазонов для данной платформы указаны заголовочном файле limits.h.

Новые типы в С99

После того, как C99 добавил тип

long long

, целочисленных типов и путаницы стало ещё больше. Чтобы навести порядок, стандарт ввёл заголовочный файл

stdint.h

, где определяются типы вроде

int16_t

(равно 16 бит),

int_least16_t

(минимальный тип, способный вместить 16 бит),

int_fast16_t

(по крайней мере 16 бит, работа с этим типом наиболее быстрая на данной платформе) и т. п.

least- и fast-типы фактически являются заменой рассмотренных выше типов int, short, long и т. п. только вдобавок дают программисту возможность выбора между скоростью и размером.

От типов вроде int16_t, со строгим указанием размера, страдает переносимость: скажем, на архитектуре с 9-битным байтом может просто не найтись 16-битного регистра. Поэтому стандарт тут явно говорит, что эти типы опциональны. Но учитывая, что какой бы код вы ни писали, чуть менее чем во всех случаях целевая архитектура фиксирована даже в худшем случае с точностью до семейства (скажем, x86 или AVR), внутри которого, размер байта не может вдруг поменяться, то переносимость фактически сохраняется. Более того, типы вроде int16_t оказались даже более популярными, чем

int_least16_t и int_fast16_t, а при низкоуровневом программировании (микроконтроллеры, драйверы устройств) и подавно, ибо там зачастую неопределённость размера переменной просто непозволительна.



1)

Для удобства тройку архитектура+ОС+компилятор далее будем называть просто

платформой

.


2)

Этот макрос правильнее было бы назвать

UCHAR_BIT

, но по причинам совместимости он называется так, как называется.

Руководство C# | Типы данных

77

C# — Руководство по C# — Типы данных

Типы данных имеют особенное значение в C#, поскольку это строго типизированный язык. Это означает, что все операции подвергаются строгому контролю со стороны компилятора на соответствие типов, причем недопустимые операции не компилируются. Следовательно, строгий контроль типов позволяет исключить ошибки и повысить надежность программ. Для обеспечения контроля типов все переменные, выражения и значения должны принадлежать к определенному типу. Такого понятия, как «бестиповая» переменная, в данном языке программирования вообще не существует. Более того, тип значения определяет те операции, которые разрешается выполнять над ним. Операция, разрешенная для одного типа данных, может оказаться недопустимой для другого.

В C# имеются две общие категории встроенных типов данных: типы значений и ссылочные типы. Они отличаются по содержимому переменной. Концептуально разница между ними состоит в том, что тип значения (value type) хранит данные непосредственно, в то время как ссылочный тип (reference type) хранит ссылку на значение.

Эти типы сохраняются в разных местах памяти: типы значений сохраняются в области, известной как стек, а ссылочные типы — в области, называемой управляемой кучей.

Давайте разберем типы значений.

Целочисленные типы

В C# определены девять целочисленных типов: char, byte, sbyte, short, ushort, int, uint, long и ulong. Но тип char применяется, главным образом, для представления символов и поэтому рассматривается отдельно. Остальные восемь целочисленных типов предназначены для числовых расчетов. Ниже представлены их диапазон представления чисел и разрядность в битах:

Целочисленные типы C#
Тип Тип CTS Разрядность в битах Диапазон
byte System. Byte 8 0:255
sbyte System.SByte 8 -128:127
short System.Int16 16 -32768 : 32767
ushort System.UInt16 16 0 : 65535
int System.Int32 32 -2147483648 : 2147483647
uint System.UInt32 32 0 : 4294967295
long System.Int64 64 -9223372036854775808 : 9223372036854775807
ulong System.UInt64 64 0 : 18446744073709551615

Как следует из приведенной выше таблицы, в C# определены оба варианта различных целочисленных типов: со знаком и без знака. Целочисленные типы со знаком отличаются от аналогичных типов без знака способом интерпретации старшего разряда целого числа. Так, если в программе указано целочисленное значение со знаком, то компилятор C# сгенерирует код, в котором старший разряд целого числа используется в качестве флага знака. Число считается положительным, если флаг знака равен 0, и отрицательным, если он равен 1.

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

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

Так, если значение нужно сохранить без знака, то для него можно выбрать тип uint, для больших значений со зн

Golang Integer — работа с int32, int64, uint, uint8, uint16, uint32 и uint64

Под конец урока вы сможете:

  • Использовать 10 типов целых чисел;
  • Выбрать верный тип при написании кода;
  • Использовать шестнадцатеричные и двоичные значения.

В Go есть 10 типов данных для целых чисел. В общем и целом их называют integer. У типов integer нет проблем с точностью, что присуща числам с плавающей запятой float, однако их нельзя использовать для хранения дробей, их диапазон также ограничен. Тип выбранного целого числа зависит от диапазона значений, которые необходимы для данной конкретной ситуации.

Форум Гоферов

Мы работаем над форумом для программистов на Golang. Очень нужны модераторы которые хотят помочь с ответами для новичков и помочь в развитии Go-сообщества.

Go на Форум

Уроки, статьи и Видео

Мы публикуем в паблике ВК и Telegram качественные обучающие материалы для быстрого изучения Go. Подпишитесь на нас в ВК и в Telegram. Поддержите сообщество Go программистов.

Go в ВК Go в Telegram

Содержание статьи

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

В основе компьютеров находятся биты. Бит может либо отсутствовать, либо представлен в виде 0 или 1. Восемь битов могут представлять 256 различных значений. Как много битов понадобится для представления числа 4 000 000 000?

Объявление переменных integer в Golang

Пять целочисленных типов Go являются подписанными, или знаковыми. Это значит, что они могут представлять как положительные, так и отрицательные целые числа. Самым популярным знаковым типом целых чисел является int:

Другие пять целочисленных типов являются неподписанными, то есть они лишь для положительных чисел. Для неподписанных целых чисел используется аббревиатура uint:

При использовании назначения типа для целого числа Go всегда выберет тип int. Следующие три строки кода эквиваленты:

year := 2018 var year = 2018 var year int = 2018

year := 2018

var year = 2018

var year int = 2018

На заметку: При возможности лучше опускать уточнение типа int. Точно также как можно не уточнять тип числа с плавающей запятой float64.

Вопрос для проверки:

Если стакан наполовину полон, какое тип целого числа вы используете для представления количества миллилитров воды в стакане?

Ответ на вопрос

Тип uint (неподписанный integer), что только для положительных целых чисел.

Тип uint (неподписанный integer), что только для положительных целых чисел.

Тип целого числа integer для каждого случая Golang

Целые числа, будь они подписанными или нет, отличаются по размеру. Размер влияет на минимальное и максимальное значение, а также на то, сколько памяти они занимают. Есть восемь независимых от архитектуры типов суффиксов с количеством необходимых битов. Показано в следующей таблице:

Тип Диапазон Занимаемая память
int8 –128 — 127 8 бит (1 байт)
uint8 0 — 255
int16 –32 768 — 32 767 16 бит (2 байта)
uint16 0 — 65535
int32 –2 147 483 648 — 2 147 483 647 32 бита (4 байта)
uint32 0 — 4 294 967 295
int64 –9 223 372 036 854 775 808 — 9 223 372 036 854 775 807 64 бита (8 байт)
uint64 0 — 18 446 744 073 709 551 615

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

В таблице выше не указано два целочисленных типа. Типы int и uint оптимальны для целевого устройства. Go Playground, Raspberry Pi 2 и более старые мобильные устройства обеспечивают 32-битную среду, int и uint являются 32-битными значениями. Любой современный компьютер может обеспечить 64-битную среду, где int и uint будут 64-битными значениями.

На заметку: Если работаете на компьютере с 32-битной архитектурой над кодом, в котором используются числа со значениями более двух миллиардов, не забудьте использовать типы int64 и uint64 вместо int и uint.

Может показаться, что на некоторых устройствах int идентичен int32, а на других — int64, все-таки это три разных типа. Тип int не является заменой других типов.

Вопрос для проверки:

Какой целочисленный тип включает значение –20 151 021?

Ответ на вопрос

Подойдут типы int32, int64 и int.

Подойдут типы int32, int64 и int.

Выбор правильного типа данных для целых чисел в Go

Узнать, к какому типу данных компилятор Go относит определенную переменную, можно через функцию Printf. У нее есть специальный символ %T, что выводит тип переменной. Это показано в примере ниже.

year := 2018 fmt.Printf(«Type %T for %v\n», year, year) // Выводит: Type int for 2018

year := 2018

fmt.Printf(«Type %T for %v\n», year, year) // Выводит: Type int for 2018

Вместо повторения переменной дважды можно указать Printf, чтобы тот использовал первый аргумент [1] для второго специального символа для форматирования:

days := 365.2425 fmt.Printf(«Type %T for %[1]v\n», days) // Выводит: Type float64 for 365.2425

days := 365.2425

fmt.Printf(«Type %T for %[1]v\n», days) // Выводит: Type float64 for 365.2425

Задание для проверки:

Какие типы данных Go присвоит тексту в кавычках, целому числу, вещественному числу и слову true (без кавычек)? Напишите простой код, где будут объявляться переменные с различными значениями. Запустите программу и посмотрите, к какому типу Go отнесет каждую переменную.

Решение


a := «text» fmt.Printf(«Type %T for %[1]v\n», a) // Выводит: Type string for text b := 42 fmt.Printf(«Type %T for %[1]v\n», b) // Выводит: Type int for 42 c := 3.14 fmt.Printf(«Type %T for %[1]v\n», c) // Выводит: Type float64 for 3.14 d := true fmt.Printf(«Type %T for %[1]v\n», d) // Выводит: Type bool for true

a := «text»

fmt.Printf(«Type %T for %[1]v\n», a) // Выводит: Type string for text

 

b := 42

fmt.Printf(«Type %T for %[1]v\n», b) // Выводит: Type int for 42

 

c := 3.14

fmt.Printf(«Type %T for %[1]v\n», c) // Выводит: Type float64 for 3.14

 

d := true

fmt.Printf(«Type %T for %[1]v\n», d) // Выводит: Type bool for true



[crayon-5fad031386b04513098914/]

Шестнадцатеричные значения в Go

Цвета в CSS указываются шестнадцатеричными, а не десятичными значениями. В шестнадцатеричной системе используется на 6 знаков больше, чем в десятичной. Первые десять те же самые — от 0 до 9, за ними следуют символы от A до F. A является эквивалентом 10 в десятичной системе, B — 11 и так далее до F, что соответствует 15.

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

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

Шестнадцатеричное значение Десятичное значение
A 10
F 15
10 16
FF 255

Для различия между шестнадцатеричными и десятичными значениями Go запрашивает префикс для шестнадцатеричных значений. Следующие две строки кода эквиваленты:

var red, green, blue uint8 = 0, 141, 213 var red, green, blue uint8 = 0x00, 0x8d, 0xd5

var red, green, blue uint8 = 0, 141, 213

var red, green, blue uint8 = 0x00, 0x8d, 0xd5

Для отображения чисел в шестнадцатеричной системе можно использовать специальные символы %x или %X с Printf:

fmt.Printf(«%x %x %x», red, green, blue) // Выводит: 0 8d d5

fmt.Printf(«%x %x %x», red, green, blue) // Выводит: 0 8d d5

Для вывода цвета, что будет уместен в файле .css, шестнадцатеричным значениям нужны отступы. С помощью специальных символов %v и %f можно уточнить минимальное количество знаков [2] и нулевой отступ с %02х:

fmt.Printf(«color: #%02x%02x%02x;», red, green, blue) // Выводит: color #008dd5;

fmt.Printf(«color: #%02x%02x%02x;», red, green, blue) // Выводит: color #008dd5;

Вопрос для проверки:

Сколько байтов требуется для хранения значения типа uint8?

Ответ

8-битное (неподписанное) целое число запрашивает всего один байт.

8-битное (неподписанное) целое число запрашивает всего один байт.

Целочисленное переполнение в Go

Целым числам не присущи ошибки округления, характерные для менее точных чисел с плавающей запятой. Тем не менее, у всех целочисленных типов есть другая проблема: ограниченный диапазон. При выходе за пределы типового диапазона Go сталкивается с таким явлением, как целочисленное переполнение.

У 8-битного неподписанного целого числа (uint8) диапазон 0-255. Значения выше 255 возвращаются к 0. Следующая программа увеличивает подписанные и неподписанные 8-битные целые числа, что в конечном итоге приводит к целочисленному переполнению.

var red uint8 = 255 red++ fmt.Println(red) // Выводит: 0 var number int8 = 127 number++ fmt.Println(number) // Выводит: -128

var red uint8 = 255

red++

fmt.Println(red) // Выводит: 0            

 

var number int8 = 127

number++

fmt.Println(number) // Выводит: -128

Биты целочисленных значений

Для того чтобы понять, почему при выходе из диапазона целые числа сбрасываются, рассмотрим биты. Специальный символ %b покажет биты целочисленного значения. Как и другие специальные символы %b может задействовать нулевой отступ с минимальной длиной, что показано в следующем примере:

var green uint8 = 3 fmt.Printf(«%08b\n», green) // Выводит: 00000011 green++ fmt.Printf(«%08b\n», green) // Выводит: 00000100

var green uint8 = 3

fmt.Printf(«%08b\n», green) // Выводит: 00000011

green++

fmt.Printf(«%08b\n», green) // Выводит: 00000100

Задание для проверки:

Используйте Go Playground, чтобы поэкспериментировать с целочисленным переполнением:

  1. Листинг 2 (один из примеров урока) увеличивает значения red и number на 1. Что произойдет при добавлении более крупного числа к каждой переменной?
  2. Рассмотрите иной вариант развития событий. Что случится при уменьшении значения red, когда то равно 0 или уменьшения number, когда то равно -128?
  3. Целочисленное переполнение также касается 16, 32 и 64-битных целых чисел. Что произойдет при объявлении uint16, присвоенного к максимальному значению 65535, а затем уменьшенному на 1?

Ответы

    1. // добавление числа больше, чем 1 var red uint8 = 255 red += 2 fmt.Println(red) // Выводит: 1 var number int8 = 127 number += 3 fmt.Println(number)

      // добавление числа больше, чем 1

      var red uint8 = 255

      red += 2

      fmt.Println(red) // Выводит: 1              

       

      var number int8 = 127

      number += 3

      fmt.Println(number)

    2. // переполнение с другой стороны red = 0 red— fmt.Println(red) // Выводит: 255 number = -128 number— fmt.Println(number)

      // переполнение с другой стороны

      red = 0

      red—

      fmt.Println(red) // Выводит: 255            

       

      number = -128

      number—

      fmt.Println(number)

    3. // переполнения 16-битного неподписанного целого числа var green uint16 = 65535 green++ fmt.Println(green) // Выводит: 0

      // переполнения 16-битного неподписанного целого числа

      var green uint16 = 65535

      green++

      fmt.Println(green) // Выводит: 0

    1. [crayon-5fad031386b0e930745438/]
    2. [crayon-5fad031386b0f148732751/]
    3. [crayon-5fad031386b10272527162/]

Пакет math определяет math.MaxUint16 как 65535 и min/max константы для каждого независимого от архитектуры целочисленного типа. Помните, что int и uint могут быть как 32, так и 64-битными, зависит от компьютера.

В примере выше (Листинг 3) увеличение green приводит к перемещению 1, что оставляет нули справа. Результат 00000100 является бинарным, что равняется 4 в десятичной системе. Это показано на схеме ниже.

Перемещение 1 в бинарном дополнении

То же самое происходит при увеличении 255. Однако есть одна кардинальная разница: оставшейся только с восемью доступными битами переместившейся 1 некуда больше деваться, поэтому значение blue остается как 0. Это показано в следующей схеме:

Куда перемещаться дальше?

var blue uint8 = 255 fmt.Printf(«%08b\n», blue) // Выводит: 11111111 blue++ fmt.Printf(«%08b\n», blue) // Выводит: 00000000

var blue uint8 = 255

fmt.Printf(«%08b\n», blue) // Выводит: 11111111        

blue++

fmt.Printf(«%08b\n», blue) // Выводит: 00000000

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

Вопрос для проверки: 

Какой специальный символ нужно использовать, чтобы увидеть биты?

Ответ

Специальный символ %b выводит целые числа с основанием 2.

Специальный символ %b выводит целые числа с основанием 2.

Как избежать переполнения по времени в Go

В операционных системах на основе Unix время представлено в виде количества секунд, начиная с 1 Января 1970 UTC (Coordinated Universal Time). В 2038 году число секунд с 1 Января 1970 году превысит 2 миллиарда, что является пределом для int32.

К счастью, int64 сможет поддерживать даты, следующие после 2038 года. Это одна из тех ситуаций, когда int32 или int совсем не подойдут. Только целочисленные типы int64 и uint64 могут хранить числа крупнее двух миллиардов на всех платформах.

Код ниже использует функцию Unix из пакета time. Она принимает два параметра int64, отвечая на количество секунд и наносекунд с 1 Января 1970 года. Использование подходящего крупного значения (более 12 миллиардов) демонстрирует, что датами после 2038 года можно будет оперировать в Go.

package main import ( «fmt» «time» ) func main() { future := time.Unix(12622780800, 0) fmt.Println(future) // Выводит: 2370-01-01 00:00:00 +0000 UTC в Go Playground }

package main

 

import (

    «fmt»

    «time»

)

 

func main() {

    future := time.Unix(12622780800, 0)

    fmt.Println(future) // Выводит: 2370-01-01 00:00:00 +0000 UTC в Go Playground            

}

Вопрос для проверки:

Какой тип целых чисел лучше использовать, чтобы избежать целочисленного переполнения?

Ответ

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

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

Заключение

  • Самыми популярными целочисленными типами являются int и uint, однако в некоторых ситуациях лучше использовать типы с меньшим или большим диапазоном;
  • Важно внимательно выбирать целочисленные типы — это поможет избежать переполнения. Хотя в некоторых случаях оно может потребоваться;
  • Мы рассмотрели 10 из 15 числовых типов Go — int, int8, int16, int32, int64, uint, uint8, uint16, uint32 и uint64.

Итоговое задание для проверки:

Напишите программу для копилки, где для подсчета количества центов (не долларов) будут использоваться целые числа. В копилку случайным образом будут складываться монеты в пять (5¢), десять (10¢) и двадцать пять (25¢) центов до тех пор, пока в копилке не будет 25 долларов ($25).

Пускай программа показывает баланс после каждого добавления монет в копилку. Баланс должен отображаться в долларах. К примеру, $1.05.

При необходимости найти остаток от деления двух чисел используйте оператор модуля %.

Решение


package main import ( «fmt» «math/rand» ) func main() { piggyBank := 0 for piggyBank < 2000 { switch rand.Intn(3) { case 0: piggyBank += 5 case 1: piggyBank += 10 case 2: piggyBank += 25 } dollars := piggyBank / 100 cents := piggyBank % 100 fmt.Printf(«$%d.%02d\n», dollars, cents) } }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

package main

 

import (

    «fmt»

    «math/rand»

)

 

func main() {

    piggyBank := 0

 

    for piggyBank < 2000 {

        switch rand.Intn(3) {

        case 0:

            piggyBank += 5

        case 1:

            piggyBank += 10

        case 2:

            piggyBank += 25

        }

 

        dollars := piggyBank / 100

        cents := piggyBank % 100

        fmt.Printf(«$%d.%02d\n», dollars, cents)

    }

}



[crayon-5fad031386b16066113436/]

Понравилась статья?

Поддержи наш проект, чтобы мы могли создать больше хорошего контента!

Целочисленные типы C

Резюме : в этом руководстве вы изучите различные целые типы C , включая целые числа со знаком и без знака.

C целочисленных типов со знаком

C предоставляет пять целочисленных типов со знаком. У каждого целочисленного типа есть несколько синонимов.

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

Целочисленные типы Синонимы Примечания
подписанный символ
int подписанный, подписанный int
короткий короткий int, подписанный короткий, подписанный короткий int
длинный длинный int, подписанный длинный, подписанный длинный int
длинный длинный длинный длинный int, signed long long, signed long long int Доступно с C99

Целочисленные типы C без знака

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

В следующей таблице показан беззнаковый целочисленный тип:

Целочисленные типы со знаком Целочисленные типы без знака
char unsigned char
int unsigned int
short unsigned short
long unsigned long
long long unsigned long long

целочисленные типы C диапазоны значений

C точно определяет минимальный размер хранилища каждого целочисленного типа e.g., short занимает минимум два байта, long занимает не менее 4 байтов. Независимо от реализации C, размер целочисленных типов должен соответствовать следующему порядку:

sizeof (short) & lt; sizeof (int) & lt; sizeof (длинный) & lt; sizeof (long long)

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

900 27 2 байта
Тип Размер хранилища Минимальное значение Максимальное значение
char 1 байт -128 127
беззнаковый символ 1 байт 0 255
подписанный символ 1 байт -128 127
int 2 байта или 4 байта -32 768 или -2 147 483 648 32 767 или 2 147 483 647
int без знака 2 байта или 4 байта 0 65 535 или 2 147 483 647 900 короткий 2 байта -32768 32767
беззнаковый короткий 0 65,535
длинный 4 байта -2 147 483 648 2147 483 647
беззнаковый длинный 4 байта 0 4294967295
длинный 8 байт -9,223,372,036, 854,775,808 9,223,372,036, 854,775,807
беззнаковое длинное длинное 8 байт 0 18,446,744073, 709,551,615
диапазонов значений можно найти в 9000 диапазонах целых чисел лимитов.h заголовочный файл . Этот файл заголовка содержит макросы, которые определяют минимальные и максимальные значения каждого целого типа, например, INT_MIN , INT_MAX для минимального и максимального размера целого числа.

Получение размеров целочисленных типов

Чтобы получить размер целочисленного типа или любого другого типа, вы используете оператор sizeof () . Следующая программа демонстрирует, как использовать оператор sizeof () для получения размеров различных целочисленных типов в вашей системе.

1

2

3

4

5

6

7

8

9

10

11

13 140007

000

16

17

18

/ *

* Файл: main.c

* Автор: zentut.com

* Назначение: отображение размеров целочисленных типов

* /

#include < stdio.h>

int main ()

{

printf («sizeof (короткий) =% d байтов \ n», sizeof (короткий));

printf («sizeof (int) =% d bytes \ n», sizeof (int));

printf («sizeof (unsigned int) =% d байтов \ n», sizeof (unsigned int));

printf («sizeof (long) =% d bytes \ n», sizeof (long));

возврат 0;

}

Следующий вывод нашей системы:

sizeof (short) = 2 байта

sizeof (int) = 4 байта

sizeof (unsigned int) = 4 байта

sizeof (long) = 4 байта

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

  • Было ли это руководство полезным?
  • Да Нет

Размер int — C / C ++

П: н / д

Привет,

Говорят, что размер short, int, long, float и double зависит от
машины, тогда как размер char составляет 1 байт.
Итак, что они подразумевают под размером в зависимости от машины? Я имею в виду, что если у меня
32-битная машина, то каков будет размер int?

Спасибо.

Поделитесь этим вопросом


П: н / д

Нихил Бокаре
Говорят, что размер short, int, long, float и double зависит от
машины, тогда как размер char составляет 1 байт.
Итак, что они подразумевают под размером в зависимости от машины? Я имею в виду, что если у меня
32-битная машина, то каков будет размер int?
Размеры предопределенных целочисленных типов зависят от компилятора.Модель
решение автора компилятора, скорее всего, будет руководствоваться
характеристики машины, но могут быть и другие соображения
а также совместимость с другими системами.

На 32-битной машине размер int будет (a) sizeof (int) по определению
, (b) независимо от размера, выбранного авторами компилятора, (c) * вероятно *
будет 32-битным, но это не гарантируется языком.

См. Раздел 1 FAQ по comp.lang.c .


Кейт Томпсон (The_Other_Keith) ks***@mib.org
Суперкомпьютерный центр Сан-Диего <*
«Мы должны что-то сделать. Это что-то. Следовательно, мы должны это сделать».
— Энтони Джей и Джонатан Линн, «Да министр»


П: н / д

12 июня, 15:10, Кейт Томпсон,
Нихил Бокаре <нбок... @ gmail.com пишет:
Говорят, что размер short, int, long, float и double зависит от
машины, тогда как размер char составляет 1 байт.
Итак, что они подразумевают под размером в зависимости от машины? Я имею в виду, что если у меня
32-битная машина, то каков будет размер int?

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

На 32-битной машине размер int будет (a) sizeof (int) по определению
, (b) независимо от размера, выбранного авторами компилятора, (c) * вероятно *
будет 32-битным, но это не гарантируется языком.

И (d) достаточно большой, чтобы содержать значение INT_MAX
См. Раздел 1 FAQ по comp.lang.c, .

П: н / д

Лью Кувшин
12 июня в 15:10 Кейт Томпсон […]
> На 32-битной машине размер int будет (a) sizeof (int) по определению
, (b) независимо от размера, выбранного авторами компилятора, (c) * вероятно *
будет 32-битным, но это не гарантируется языком.

И (d) достаточно большой, чтобы содержать значение INT_MAX
Гарантированно будет не менее 32767.


Кейт Томпсон (The_Other_Keith) ks***@mib.org
Суперкомпьютерный центр Сан-Диего <*
«Мы должны что-то сделать. Это что-то. Следовательно, мы должны это сделать».
— Энтони Джей и Джонатан Линн, «Да министр»


П: н / д

Нихил Бокаре написал, 06.12.07, 19:22:
Привет,

Говорят, что размер short, int, long, float и double зависит от
машины, тогда как размер char составляет 1 байт.
Итак, что они подразумевают под размером в зависимости от машины?

Именно то, что написано. Собственно, это зависит от реализации с
иногда есть разные компиляторы (или один и тот же компилятор с
разные варианты), где размер некоторых из этих вещей отличается.
Я имею в виду, что если у меня
32-битная машина, то каков будет размер int?
Это зависит от того, что вы имеете в виду под 32-битной машиной и размером
байт.Это не просто придирки, я использовал 16-битные процессоры
байтов, другие здесь использовали процессоры с 32-битными байтами. Итак, 32-битный
int может быть размером от 1 байта или до 4 (при отсутствии заполнения).
Или у вас может быть 32-битный процессор, но компилятор, обеспечивающий 16
бит int, и да, это происходит.

Флэш Gordon

П: н / д

Флэш Гордон написал:
>
Нихил Бокаре писал, 07.12.07 19:22:
[…]
Я имею в виду, что если у меня
32-битная машина, то каков будет размер int?

Это зависит от того, что вы имеете в виду под 32-битной машиной и размером
байт. Это не просто придирки, я использовал процессоры с 16-битными
байтами, другие здесь использовали процессоры с 32-битными байтами.
И в этих системах возможно, что символы были 16- или 32-битными,
и все же sizeof (char) по определению остается единым.
Таким образом, 32-битное значение
int может быть размером от 1 байта или до 4 (без заполнения).
Или у вас может быть 32-битный процессор, но компилятор, который предоставляет 16
-битных int, и да, это действительно происходит.
И в настоящее время «64-битный процессор» с 32-битным int. (Или даже
16-битное int, хотя это маловероятно при использовании «современного» компилятора
нацелено на эту платформу.)


+ ————————- + ————- ——- + ———————— +
| Кеннет Дж. Броуди | www.hvcomputer.com | #include |
| kenbrody / at \ spamcop.чистая | www.fptech.com | + ————————- + ——————— + — ———————- +
Не пишите мне по адресу:

Эта дискуссия закрыта.

Ответы на это обсуждение отключены.

Статистика вопросов

  • просмотрено: 38778
  • ответов: 5
  • дата запроса: 12 июня 2007 г.

Размер переменных C ++

  1. 9039 C ++ Размер переменных C ++

Стивен Р.Davis

C ++ позволяет расширять целочисленные типы переменных, добавляя вперед следующие дескрипторы: const, unsigned, short или else long. Таким образом, вы можете объявить что-то вроде следующего:

 беззнаковое длинное int ulnVariable; 

Постоянная переменная не может быть изменена. Все числа неявно константы. Таким образом, 3 имеет тип const int, 3.0 — const double, а «3» — const char.

Беззнаковая переменная может принимать только неотрицательные значения; однако он может обрабатывать число примерно в два раза больше, чем его подписанный брат.Таким образом, беззнаковое int имеет диапазон от 0 до 4 миллиардов (в отличие от обычного диапазона signedint от -2 до 2 миллиардов).

C ++ позволяет объявлять короткие int и длинные int. Например, короткое int занимает меньше места, но имеет более ограниченный диапазон, чем обычное int, тогда как длинное int занимает больше места и имеет значительно больший диапазон.

Предполагается int. Таким образом, следующие два заявления принимаются и полностью эквивалентны:

 long int lnVar1; // объявляем длинное int
long lnVar2; // также long int; предполагается int 

Стандарт C ++ 2011 даже определяет long long int и long double.Они похожи на long int и double соответственно, только в большей степени — с большей точностью и большим диапазоном.

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

Общие типы переменных C ++
Тип Объявление константы Что это такое
внутренний 1 Простое счетное число, положительное или отрицательное.
целое число без знака 1U Неотрицательное счетное число.
короткий внутренний Потенциально уменьшенная версия int. Он использует меньше памяти, но имеет более ограниченный диапазон
.
длинный внутренний Потенциально увеличенная версия типа int. Он может использовать больше памяти, но имеет больший диапазон
.
длинный длинный внутренний 1LL Версия int, которая на
потенциально больше.
поплавок 1.0F Действительное число одинарной точности.
двойной 1,0 Действительное число двойной точности.
длинный двойной Потенциально большее число с плавающей запятой. На ПК длинное двойное — это собственный размер для чисел
, встроенных в числовой процессор.
симв. ‘c’ В одной переменной char хранится
одиночных символов.Не подходит для арифметики.
wchar_t L’c ’ Широкий персонаж. Используется для хранения больших наборов символов, таких как
китайских идеограмм и японских символов кандзи. Также известен как UTF или
Unicode.

Как далеко различаются числа?

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

В стандарте 2011 года сказано немного больше — например, длинное целое число должно быть не менее 32 бит, — но он по-прежнему не определяет размер каждого типа переменной.

Авторы C ++ не пытались быть загадочными. Они хотели позволить компилятору реализовать максимально быстрый код для базовой машины. Стандарт был разработан для работы со всеми типами процессоров, работающих под управлением разных операционных систем.

Фактически, стандартный размер int изменился за последние десятилетия. До 2000 года стандартное int на большинстве ПК было 2 байта и имело диапазон плюс-минус 64000. Примерно в 2000 году базовый размер слова в процессорах Intel изменился на 32 бита. Большинство компиляторов перешли на стандартное int, используемое сегодня — это 4 байта и диапазон значений плюс-минус 2 миллиарда.

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

Диапазон числовых типов
Тип Размер [байты] Точность Диапазон
короткий внутренний 2 точное −32 768 до 32 767
внутренний 4 точное -2 147 483 648 до 2 147 483 647
длинный внутренний 4 точное −2 147 483 648 до 2 147 483 647
длинный длинный внутренний 8 точное -9,223,372,036,854,775,808 до
9,223,372,036,854,775,807
поплавок 4 7 цифр +/− 3.4028 * 10 +/- 38
двойной 8 16 цифр +/− 1.7977 * 10 +/- 308
длинный двойной 12 19 цифр +/− 1,1897 * 10 +/- 4932

Попытка вычислить число, выходящее за пределы диапазона типа переменной, известна как переполнение . Стандарт C ++ обычно оставляет неопределенными результаты переполнения.Это еще один способ, которым изобретатели C ++ хотели оставить язык гибким, чтобы сгенерированный машинный код работал как можно быстрее.

На ПК переполнение с плавающей запятой генерирует исключение, которое, если не обработано, вызовет сбой вашей программы. Как бы плохо это ни звучало, целочисленное переполнение еще хуже — C ++ генерирует неверный результат без жалоб.

Об авторе книги

Стивен Р.Дэвис — автор бестселлеров множества книг и статей, в том числе C ++ для чайников .

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

Ваш адрес email не будет опубликован. Обязательные поля помечены *