Long int: C++ | Типы данных

Содержание

В чем разница между long long и long int



Я знаю разницу между long и int Но в чем разница между «long long» и «long int»

c++ c linux type-conversion
Поделиться Источник Syedsma     11 августа 2011 в 13:56

8 ответов


  • в чем разница между long long int и long double?

    это вопрос в spoj atoms in the lab. http:/ / www.spoj.com / problems / ATOMS / приведенный ниже код дает мне tle в spoj В этом вопросе ясно сказано,что n,m, k-целые числа. #include <iostream> #include <algorithm> #include <stdio.h> #include <complex> #define ll long long…

  • В чем разница между int и long?

    Возможный Дубликат : В чем разница между int и long в C++? разница в типах данных long vs int в C++ В c++ это разница между типом данных int и long. Написал следующий код: int _tmain(int argc, _TCHAR* argv[]) { cout<<Int_Max = <<INT_MAX<<endl; cout<<Int_Min =…



25

Существует несколько сокращений для встроенных типов.

  • short — это ( signed ) short int
  • long — это ( signed ) long int
  • long long — это ( signed ) long long int .

Во многих системах short является 16-разрядным, long -32-разрядным, а long long -64-bit. Однако имейте в виду, что стандарт требует только

sizeof(char) == 1
sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

И следствием этого является то, что в экзотической системе возможно sizeof(long long) == 1 .

Поделиться André Caron     11 августа 2011 в 14:00



10

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

int                     -32767 to               +32767 representable in 16 bits
long               -2147483647 to          +2147483647 representable in 32 bits
long long -9223372036854775807 to +9223372036854775807 representable in 64 bits

Каждый из них может быть представлен таким образом, чтобы поддерживать более широкий диапазон. В обычных 32-битных системах int и long имеют одинаковое 32-битное представление.

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

Поделиться Nicola Musatti     11 августа 2011 в 14:05



4

В системах 64 bit это не имеет никакого значения в их размерах. В 32-битных системах long long гарантированно хранит значения диапазона 64 bit.

Просто чтобы избежать всех этих путаниц, всегда лучше использовать стандартные интегральные типы: (u)int16_t, (u)int32_t and (u)int64_t , доступные через stdint.h , которые обеспечивают прозрачность.

Поделиться Arun     20 августа 2011 в 06:29


  • В чем разница между long long и long

    В чем разница между долго-долго и долго-долго? И они оба не работают с 12-значными числами (600851475143), я что-то забыл? #include <iostream> using namespace std; int main(){ long long a = 600851475143; }

  • В чем разница между «long», «long long», «long int», and «long long int» в C++?

    Я перехожу с Java на C++, и у меня есть некоторые вопросы о типе данных long . В Java, чтобы удержать целое число больше 2 32 , вы просто напишете long x; . Однако в C++ кажется, что long — это и тип данных, и модификатор. Кажется, есть несколько способов использовать long : long x; long long x;…



4

long long может быть более крупным типом, чем long int . Например, для x86 32-битный long long будет типом 64-bit, а не 32-битным для long int .

Поделиться Mark B     11 августа 2011 в 13:59



2

Значение int в 16-битных системах составляло 16 бит. «long» было введено как 32-битное целое число, но в 32-битных системах

long и int означают одно и то же (оба 32-битные.) Таким образом, в системах 32 и 64 bit long long и long int являются 64 bit. Исключение составляет 64 bit UNIX, где long -64 бита.

Более подробную таблицу смотрите в статье Википедии integer .

Поделиться richardolsson     11 августа 2011 в 14:00



1

long int -это синоним слова «долго». long long int — это синоним long long .

Единственная гарантия, которую вы имеете в стандарте C++, заключается в том, что long long по крайней мере так же велик, как long , но может быть длиннее. Это указано в §3.9.1.2 в самом последнем общедоступном проекте стандарта n3242.

Поделиться pmr

    11 августа 2011 в 14:02



1

Стандарт C не предъявляет каких-либо конкретных требований к ширине для целых типов, кроме минимальных диапазонов значений, которые должен представлять тип, и что ширина не уменьшается: short <= int <= long int <= long long int (аналогично для типов без знака). кстати, long long стал частью стандарта только в C99 и C++0x. Минимальные требуемые диапазоны можно найти в этой статье Википедии .

Поделиться Kerrek SB     11 августа 2011 в 14:03



-1

Я думаю :

«long» удваивает количество битов, выделенных для типа данных. Так долго (32 бита?) становится 64 бит. Int (16 бит?) становится 32 бит.

Поделиться cs94njw     11 августа 2011 в 14:10


Похожие вопросы:


Является ли «long long» = «long long int» = «long int long» = «int long long»?

Я обнаружил, что и long int long , и int long long могут компилироваться для типа переменной. Есть ли разница между long int long , int long long , long long и long long int ? В общем, является ли…


Разница между long и int в C#?

В чем фактическая разница между long и int в C#? я понимаю, что в C/C++ long будет 64-битным на некоторых 64-битных платформах (в зависимости от OS, конечно), но в C# все это работает в среде…


Разница между типами данных long и int

Учитывая, что следующие операторы возвращают 4 , в чем разница между типами int и long в C++? sizeof(int) sizeof(long)


в чем разница между long long int и long double?

это вопрос в spoj atoms in the lab. http:/ / www.spoj.com / problems / ATOMS / приведенный ниже код дает мне tle в spoj В этом вопросе ясно сказано,что n,m, k-целые числа. #include <iostream>…


В чем разница между int и long?

Возможный Дубликат : В чем разница между int и long в C++? разница в типах данных long vs int в C++ В c++ это разница между типом данных int и long. Написал следующий код: int _tmain(int argc,…


В чем разница между long long и long

В чем разница между долго-долго и долго-долго? И они оба не работают с 12-значными числами (600851475143), я что-то забыл? #include <iostream> using namespace std; int main(){ long long a =…


В чем разница между «long», «long long», «long int», and «long long int» в C++?

Я перехожу с Java на C++, и у меня есть некоторые вопросы о типе данных long . В Java, чтобы удержать целое число больше 2 32 , вы просто напишете long x; . Однако в C++ кажется, что long — это и…


В чем разница между вводом long x = 43 и long x = 43L в Java?

В чем будет разница между long x = 43 и long x = 43L в Java? Оба ли они инициализируют x, чтобы иметь тип данных long?


В чем разница между Int64 и long в C#?

В чем разница между Int64 и long в C#,? Пример: long x = 123; Int64 x = 123;


Разница между int() и long()

В чем разница между int(x) и long(x) в python Мое понимание : long() всегда будет возвращаться долго int() вернет int или long (если он слишком большой) таким образом, int() достаточно, чтобы…

В чем разница между «long», «long long», «long int» и «long long int» в C ++?

longи long intидентичны. Так long longи есть long long int. В обоих случаях intопционально.

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

Контролирующие части стандарта (C ++ 11, но это было давно), например

3.9.1 Fundamental types, раздел 2 (в следующем разделе приведены аналогичные правила для целых типов без знака):

Существует пять стандартных целочисленных типов со знаком: char со знаком, short int, int, long int и long long int. В этом списке каждый тип обеспечивает как минимум столько же памяти, сколько предшествует ему в списке.

Также есть таблица 9 7.1.6.2 Simple type specifiers, которая показывает «сопоставления» спецификаторов с реальными типами (показывая, что intэто необязательно), раздел которых показан ниже:

Specifier(s)         Type
-------------    -------------
long long int    long long int
long long        long long int
long int         long int
long             long int

Обратите внимание на различие между спецификатором и типом. Спецификатор — это то, как вы сообщаете компилятору, что это за тип, но вы можете использовать разные спецификаторы, чтобы получить один и тот же тип.

Следовательно, сам longпо себе не является ни типом, ни модификатором, как предполагает ваш вопрос, это просто спецификатор для long intтипа. То же long longсамое для спецификатора long long intтипа.

Хотя сам стандарт C ++ не определяет минимальные диапазоны целочисленных типов, он ссылается на C99 в 1.2 Normative referencesкачестве применяемого. Следовательно, минимальные диапазоны, изложенные в C99 5.2.4.2.1 Sizes of integer types <limits.h>, применимы.


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

unsigned-long-long-int — Русский — it-swarm.com.ru

unsigned-long-long-int — Русский — it-swarm.com.ru

it-swarm.com.ru

Java эквивалент unsigned long long?

Используя long int в PHP

Вычисление битов, необходимых для хранения десятичного числа

Как напечатать «unsigned long» в C?

Длинный без подписи на Java

c ++ uint, unsigned int, int

производительность без знака против целых чисел со знаком

Почему int, а не unsigned int используется для циклов C и C++ для циклов?

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

C/C++ использование int или unsigned int

какой смысл использовать unsigned int в C?

Какой тип данных «длинный длинный»?

Могу ли я конвертировать долго в INT?

Как использовать длинный идентификатор в приложениях Rails?

Как мне конвертировать из int в Long в Java?

Какое максимальное число с плавающей точкой в ​​Python?

Какая разница между длинным длинным и длинным

Литерал xyz типа int находится вне диапазона

Умножение двух целых чисел в C++

«OverflowError: Python int слишком велик для преобразования в C long» в Windows, но не в Mac

Подписанные и неподписанные целые числа

Как определить тип переменной Python?

Итерация по std :: vector: unsigned vs знаковая переменная со знаком

Почему Java не поддерживает беззнаковые целые?

Почему у C нет беззнаковых поплавков?

В чем разница между знаковыми и беззнаковыми переменными?

что такое неподписанный тип данных?

Как получить целочисленное значение со знаком long в python?

неподписанный короткий в Java

Операция сравнения для целых чисел без знака и со знаком

Ключевое слово без знака в C ++

Двойной без знака в C ++?

Что произойдет, если я назначу отрицательное значение переменной без знака?

Как я могу инвертировать биты беззнакового байта в Java?

Предупреждение — сравнение между целочисленными выражениями со знаком и без знака

В чем разница между «int» и «uint» / «long» и «ulong»?

В чем разница между unsigned int и sign int в C?

Можем ли мы сделать неподписанный байт в Java

Почему SQL Server не поддерживает тип данных без знака?

разница между печатью адреса памяти с использованием% u и% d в C?

В чем преимущество zerofill в MySQL?

Подписанные / неподписанные сравнения

В чем разница между подписанным и неподписанным int

Преобразование char * в unsigned char *

Определяется ли поведение целочисленного вычитания без знака?

Отрицательные числа хранятся в памяти как 2-х дополнения. Как процессор узнает, отрицательные они или положительные?

Лучший способ преобразовать целое число со знаком в длинную без знака?

Объявление неподписанного целого в Java

Целые числа со знаком и без знака для длины / количества

Почему size_t без знака?

«strlen (s1) — strlen (s2)» никогда не меньше нуля

Неверное преобразование из неподписанного символа * в символ *

следует использовать size_t или ssize_t

Когда uint8_t char беззнаковый символ?

Неявное преобразование C ++ (подписано + неподписано)

Разница между size_t и unsigned int?

Как преобразовать подписанное в целое число без знака в Python

Почему целое число без знака недоступно в PostgreSQL?

VHDL присваивает литералы

Как использовать целое число без знака в Java 8 и Java 9?

Почему дополнение работает по-другому через printf?

Когда я должен просто использовать «int» по сравнению с типами, специфичными для знака или размера?

Почему целые числа без знака подвержены ошибкам?

Как я могу получить размер std :: vector как int?

Беззнаковые значения в С

Как создать случайное 64-разрядное целое число без знака в C

C инициализировать массив в шестнадцатеричных значениях

В Си, почему «подписанный int» быстрее, чем «unsigned int»?

Правильно ли определено значение std :: is_unsigned <bool> :: value?

Почему (18446744073709551615 == -1) верно?

В чем разница между подписанным и неподписанным двоичным

Почему Kotlin не поддерживает целые числа без знака?

Почему знак отличается после вычитания неподписанного и подписанного?

Генерация случайных значений в C #

Спецификация номера Java (длинная)

WordPrap очень длинная строка

Java: проверка, равен ли бит 0 или 1 в длинной

Как добавить строку в массив string []? Там нет. Добавить функцию

долго долго в C / C ++

Как я могу проверить, приведет ли умножение двух чисел к Java к переполнению?

Как конвертировать / приводить длинные в String?

Невозможно преобразовать из типа объекта в длинный

Java: случайное длинное число в диапазоне <= x <n

Почему ваш тип данных оператора switch не может быть длинным, Java?

Индикатор загрузки Chrome продолжает вращаться во время XMLHttpRequest

длинный двойной против двойного

Длительное нажатие на UITableView

принтф и длинный двойной

Конвертировать long в байтовый массив и добавить его в другой массив

Обнаружить сенсорное нажатие против длительного нажатия против движения?

Гарантируется ли `long` как минимум 32 бита?

Как мне преобразовать Long в byte [] и обратно в java

Короткий опрос и Длинный опрос для веб-приложений реального времени?

Как я могу конвертировать NSString в длинное значение?

Как преобразовать строку в длинный в JavaScript?

UIButton Long Press Event

Как я могу преобразовать данные из строки в длинные в C #

Конвертировать Double в двоичное представление?

Как печатать долго?

Максимальная квота длины строки содержимого (8192) была превышена при чтении данных XML

Content dated before 2011-04-08 (UTC) is licensed under CC BY-SA 2.64-1 18446744073709551615 Максимальное значение __int64: 9223372036854775807 Минимальное значение __int64: -9223372036854775808 Максимальное значение без знака __int64: 18446744073709551615

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

PS: верхний или нижний предел диапазона значений может быть реализован с помощью оператора сдвига влево (<<). Например:

Диапазон значений int может быть выражен как :-( 1 << 31) ~ ((1 << 31) -1)

Сдвиг на один бит влево эквивалентен умножению 2, левый оператор сдвига имеет более низкий приоритет, чем сложение и вычитание! !
 

c — C: printf с typedef unsigned long long int

У меня есть typedef, который содержит 64-битный адрес памяти в шестнадцатеричном формате, но использование %x с printf дает мне следующую ошибку:

error: format '%x' expects argument of type 'unsigned int', but argument 4 has type 'address'\

Это мое объявление typedef:

typedef unsigned long long int address;

Как мне распечатать это шестнадцатеричное значение? Спасибо!

Изменить: адрес памяти не является указателем, я читаю шестнадцатеричные значения из другого файла, и мне нужно сохранить эти 64-битные адреса в числовом виде с использованием определенного мной typedef.

0

George 6 Май 2020 в 00:21

1 ответ

Лучший ответ

Спецификатор преобразования %x ожидает, что его соответствующий аргумент будет иметь тип unsigned int. Чтобы напечатать unsigned long long, вам нужно использовать модификатор длины ll или %llx.

Handy Table

Length Modifier        Type
–––––––––––––––        ––––
             ll        (unsigned) long long
              l        (unsigned) long
              h        (unsigned) short
             hh        (unsigned) char
              j        intmax_t, uintmax_t
              z        size_t
              t        ptrdiff_t
              L        long double

Итак, чтобы отформатировать значение unsigned char как шестнадцатеричное, вы должны использовать %hhx или %hhX. Чтобы отформатировать short как десятичное, вы должны использовать %hd. Чтобы отформатировать unsigned long как восьмеричное, вы должны использовать %lo.

Беспричинная напыщенная речь

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

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

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

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

4

John Bode 5 Май 2020 в 22:57

Чем отличается Integer от LongInt?

 
Mishenka   (2005-01-26 15:36) [0]

Я посмотрел в хелпе они оба по 32 bit и оба от -2147483648 до 2147483647. В чём разница?


 
Ega23 ©   (2005-01-26 15:37) [1]

AFAIK, integer — соптимизированный для платформы тип данных.


 
Александр Иванов ©   (2005-01-26 15:40) [2]

Помню, когда integer был 2-х байтным :). А Longint — 4-х.


 
KSergey ©   (2005-01-26 15:41) [3]

integer — платформенно зависимый (размер его, в смысле)
LongInt — фиксированного размера 4 байта


 
Palladin ©   (2005-01-26 23:30) [4]


>  KSergey ©   (26.01.05 15:41)

Жьюутко спорный вопрос…
В применении делфи, это верно, Integer — Generic, Longint — Fundamental…
Но так ли это там…


 
Gero ©   (2005-01-26 23:35) [5]

Короче, ничем он не отличается.
На сегодняшний день.


 
Anatoly Podgoretsky ©   (2005-01-27 01:06) [6]

Mishenka   (26.01.05 15:36)  
LongInt 32 бита, а integer хрен его знает.


 
Германн ©   (2005-01-27 02:17) [7]

По-моему уже все точки проставлены над всем, где это нужно!
Пока только остался вопрос к Palladin ©   (26.01.05 23:30) [4]
>В применении делфи, это верно, Integer — Generic, Longint — >Fundamental…
>Но так ли это там…

А где там…?
В сабже указано — [D6, Win2k]


 
KSergey ©   (2005-01-27 06:10) [8]

> Palladin ©   (26.01.05 23:30) [4]
> Но так ли это там…

Может таки прекращать уже эту травку курить? Ну или хоть поделитесь, а то явно на разных с Вами языках разговариваем… 😉
Уже во второй ветке вижу страннейший Ваш ответ…

Присоединяюсь к Германн»у: там — это где, простите?


 
MakedoneZ ©   (2005-01-27 19:06) [9]

Вы мне профы. лучше ответьте на то какая разница между WordBool,ByteBool и LongBool все принимают 2 значения «true» «false»,а занимают разное кол-во памяти.
Где здесь логика? 🙂


 
Kerk ©   (2005-01-27 19:29) [10]

MakedoneZ ©   (27.01.05 19:06) [9]

в том и логика.. что разное кол-во памяти


 
Andy BitOff ©   (2005-01-27 20:43) [11]

На самом деле LongInt 32 бита, а integer 4 байта — вот и разница


 
Gero ©   (2005-01-27 21:03) [12]


> На самом деле LongInt 32 бита, а integer 4 байта — вот и
> разница

Хм, а по-моему наоборот…


 
Kerk ©   (2005-01-27 21:08) [13]

Ну вы ламеры!!! LongInt не 32 бита!!! Оно 2 слова!!!


 
begin…end ©   (2005-01-27 21:11) [14]

> [13] Kerk ©   (27.01.05 21:08)

Сам ты ламер. Это не 2 слова, это одно двойное слово.
🙂


 
pasha_golub ©   (2005-01-27 21:37) [15]

begin…end ©   (27.01.05 21:11) [14]
Kerk ©   (27.01.05 21:08) [13]

Оба вы ламо. Это четыре байта :Р


 
Eraser ©   (2005-01-27 22:07) [16]

begin…end ©
DWORD как и WORD — беззнаковые, а Integer- знаковый ;-))


 
Kerk ©   (2005-01-27 22:26) [17]

Eraser ©   (27.01.05 22:07) [16]
и?


 
dimaxx ©   (2005-01-27 22:55) [18]

32 бита = 2 слова = 4 байта. Вся разница в платформозависимости.


 
Andy BitOff ©   (2005-01-27 22:56) [19]

Это значит, что первые два байта положительные, а вторые два отрицательные


 
Anatoly Podgoretsky ©   (2005-01-27 23:07) [20]

Нет, только последний байт отричательный


 
Kerk ©   (2005-01-27 23:16) [21]

Andy BitOff ©   (27.01.05 22:56) [19]
Anatoly Podgoretsky ©   (27.01.05 23:07) [20]
чего-то я вас не понял.. или вы шутите.. или мне надо трезветь.


 
Kerk ©   (2005-01-27 23:22) [22]

байи бывает отрицательный?


 
SergP ©   (2005-01-27 23:33) [23]


>  [22] Kerk ©   (27.01.05 23:22)
> байи бывает отрицательный?

Ну это смотря как на него посмотреть? :-))


 
Eraser ©   (2005-01-27 23:39) [24]

Kerk ©
надо трезветь.

Скорее наоборот ;-))


 
Anatoly Podgoretsky ©   (2005-01-28 00:12) [25]

Kerk ©   (27.01.05 23:16) [21]
Пить вредно, а трезветь бессмысленно.


 
Reindeer Moss Eater ©   (2005-01-28 08:46) [26]

Без уточнения где именно сравнивают эти типы вопрос не имеет особого смысла.
Разве что можно сразу сказать, что LongInt это — физический тип, а Integer — логический (не путать с булевым).


 
rdm ©   (2005-01-31 04:14) [27]

>Вы мне профы. лучше ответьте на то какая разница между WordBool,ByteBool и LongBool все принимают 2 значения «true» «false»,а занимают разное кол-во памяти.
Boolean — true=1,false=0
ByteBool,WordBool,LongBool — false=0,true=остальные значение


c — В чем разница между unsigned long /long /int в c /c ++?

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

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

Int может быть меньше размера регистра машины в целях экономии места в памяти (большие целые занимают вдвое больше оперативной памяти, чем маленькие целые). Обычно это выглядит как 32-битный объект даже на 64-битных архитектурах, где совместимость со старыми системами и эффективность использования памяти являются первоочередными задачами.

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

Чипы ЦП, предназначенные для энергоэффективности или встроенные устройства, — вот где вы найдете различия между int и long в наши дни. Компиляторы для процессоров общего назначения, таких как настольный компьютер или ноутбук, обычно обрабатывают int и long как один и тот же размер, поскольку процессор эффективно использует 32-разрядные регистры. На меньших устройствах, таких как сотовые телефоны, ЦП может быть построен для более естественной обработки 16-битных данных и должен усердно работать для обработки 32-битных или более крупных данных.

Меньшее количество бит на регистр означает меньшее количество микросхем, необходимых для микросхемы, меньшее количество линий передачи данных для перемещения данных в микросхему и из нее, более низкое энергопотребление и меньший размер кристалла, и все это приводит к более низкой стоимости (в $ и ватт) устройство.

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

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

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

В чем разница между long, long long, long int и long long int в C ++?

long и long int идентичны. Итак, long long и long long int . В обоих случаях int не является обязательным.

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

Управляющими частями стандарта (C ++ 11, но он существует уже давно) является, например, 3.9.1 Фундаментальные типы , раздел 2 (в следующем разделе приведены аналогичные правила для беззнаковых целочисленных типов):

Существует пять стандартных целочисленных типов со знаком: signed char, short int, int, long int и long long int. В этом списке каждый тип обеспечивает как минимум такой же объем памяти, как и предыдущие в списке.

В 7.1.6.2 Спецификаторы простых типов также есть таблица 9, которая показывает «сопоставления» спецификаторов с фактическими типами (показывая, что int является необязательным), раздел которой показан ниже:

  Спецификатор (ы) Тип
------------- -------------
длинный длинный int длинный длинный int
длинный длинный длинный длинный int
длинный интервал длинный интервал
длинный длинный int
  

Обратите внимание на различие между спецификатором и типом.Спецификатор — это то, как вы сообщаете компилятору, что это за тип, но вы можете использовать разные спецификаторы, чтобы получить один и тот же тип.

Следовательно, long сам по себе не является ни типом , ни модификатором, как утверждает ваш вопрос, это просто спецификатор для типа long int . То же самое для long long является спецификатором для типа long long int .

Хотя сам стандарт C ++ не определяет минимальные диапазоны целочисленных типов, он ссылается на C99 в 1.2 Нормативные ссылки , применяемые. Следовательно, применимы минимальные диапазоны, указанные в C99 5.2.4.2.1 Размеры целочисленных типов .


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

delphi — Разница между LongInt и Integer, LongWord и Cardinal

Краткая версия

  | Тип | 16-битная платформа | 32-битная платформа | 64-битная платформа |
| ------------- | ----------------- | ---------------- | ------------------ |
| Целое | 16-битный знаковый | 32-битный подписанный | "общий тип"
| Кардинал | 16-битное беззнаковое | 32-битное беззнаковое | "общий тип"

| Longint | 32-битный подписанный | 32-битный подписанный | 64-битная подпись | «основной тип»
| Длинное слово | н / д | 32-битное беззнаковое | 64-битное беззнаковое | «основной тип»
| Int64 | н / д | 64-битная подпись | 64-битная подпись | «основной тип»
| UInt64 | н / д | 64-битное беззнаковое | 64-битное беззнаковое | «основной тип»
| Int32 | н / д | 32-битный подписанный |
| UInt32 | н / д | 32-битное беззнаковое |

| NativeInt | н / д | 32-битный подписанный | 64-битная подпись |
| NativeUInt | н / д | 32-битное беззнаковое | 64-битное беззнаковое |

| FixedInt | н / д | 32-битный подписанный |
| FixedUInt | н / д | 32-битное беззнаковое |
  

Длинный ответ

Мы все знаем, что им следовало делать:

  | Тип | 16-битная платформа | 32-битная платформа | 64-битная платформа |
| ------------- | ----------------- | ---------------- | ------------------ |
| Целое | 16-битный знаковый | 32-битный подписанный | 64-битная подпись | "общий тип"
| Кардинал | 16-битное беззнаковое | 32-битное беззнаковое | 64-битное беззнаковое | "общий тип"

| SmallInt | 16-битный знаковый | «основной тип»
| Слово | 16-битное беззнаковое | «основной тип»
| Longint | 32-битный подписанный | «основной тип»
| Длинное слово | 32-битное беззнаковое | «основной тип»
| Int64 | 64-битная подпись | «основной тип»
| UInt64 | 64-битное беззнаковое | «основной тип»
  
  • основные типы не меняются
  • универсальные типы (псевдонимы) do

Но они этого не сделали.Итак, мы там, где находимся.

Предположительно Int32 всегда будет 32-битным целым числом со знаком ; но гарантии были нарушены раньше.

Дополнительное чтение

Из справки Delphi 5:

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


Целочисленный тип представляет собой подмножество целых чисел. Общие целочисленные типы: Integer и Cardinal ; используйте их, когда это возможно, так как они обеспечивают наилучшую производительность для центрального процессора и операционной системы.В таблице ниже приведены их диапазоны и форматы хранения для текущего 32-разрядного компилятора Object Pascal.

  Тип Диапазон Формат
-------- ----------------------- ---------------
Целое число –2147483648..2147483647 32-битное со знаком
Кардинал 0..4294967295 беззнаковый 32-битный
  

Основные целочисленные типы включают Shortint , Smallint , Longint , Int64 , Byte , Word и Longword .63–1 подписанный 64-разрядный Байт 0..255 беззнаковый 8-битный Слово 0..65535 16 бит без знака Длинное слово 0..4294967295 32-битное без знака

В общем случае арифметические операции с целыми числами возвращают значение типа Integer , которое в его текущей реализации эквивалентно 32-битному Longint . Операции возвращают значение типа Int64 только при выполнении с операндом Int64 .

Обратите внимание, что «в его текущей реализации эквивалентен Longint» .Тогда предполагалось, что Integer изменится; мало ли они понимали, что изменится именно Longint .

Из руководства пользователя Delphi 1:

Типы данных


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

Таблица 5.1 Предопределенные типы данных Object Pascal

  • Целое число : числа без дробной части в диапазоне от –32768 до 32767.Требуется два байта памяти.
  • Shortint : числа без дробной части в диапазоне от –128 до 127. Требуется только один байт памяти.
  • Longint : числа без дробной части в диапазоне от –2147483647 до 2147483647. Требуется четыре байта памяти.
  • Байт : числа без дробной части в диапазоне от 0 до 255. Требуется один байт памяти.
  • Слово : числа без дробной части в диапазоне от 0 до 65535.Требуется два байта памяти

Из справки Delphi XE6:

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

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

Целочисленные типы могут быть платформенно-зависимыми и независимыми от платформы.

Целочисленные типы, зависящие от платформы


Зависимые от платформы целочисленные типы преобразуются, чтобы соответствовать размеру бит текущей платформы компилятора. Зависимые от платформы целочисленные типы: NativeInt и NativeUInt .Желательно использовать эти типы везде, где это возможно, поскольку они обеспечивают наилучшую производительность для базового процессора и операционной системы. В следующей таблице показаны их диапазоны и форматы хранения для компилятора Delphi.

Целочисленные типы, зависящие от платформы

  Тип Диапазон Формат Псевдоним
----------- ----------------------- ---------------- ---------------------- ------------
NativeInt -2147483648.64-1 Беззнаковый 64-битный на 64-битных платформах UInt64
  

Целочисленные типы, не зависящие от платформы

Независимые от платформы целочисленные типы всегда имеют одинаковый размер, независимо от того, какую платформу вы используете. Независимые от платформы целочисленные типы включают ShortInt , SmallInt , LongInt , Integer , Int64 , Byte , Word , LongWord , Cardinal и UInt.64-1 Беззнаковый 64-битный

Обратите внимание, как Integer и Cardinal были задокументированы как зависимые от платформы ? Также обратите внимание, как LongInt и LongWord были задокументированы как независимые от платформы ?

Типы данных C ++ — GeeksforGeeks

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

Типы данных в C ++ в основном делятся на три типа:

  1. Примитивные типы данных : Эти типы данных являются встроенными или предопределенными типами данных и могут использоваться пользователем непосредственно для объявления переменных. пример: int, char, float, bool и т. д.В C ++ доступны следующие примитивные типы данных:
    • Целое число
    • Символ
    • Логическое
    • Плавающая точка
    • Двойная плавающая точка
    • Бесполезная или пустая
    • Широкий символ
  2. Типы производных данных: Типы данных, которые являются производными от примитивных или встроенных типов данных и называются производными типами данных. Они могут быть четырех типов, а именно:
    • Функция
    • Массив
    • Указатель
    • Ссылка
  3. Абстрактные или определяемые пользователем типы данных : Эти типы данных определяются самим пользователем.Например, определение класса на C ++ или структуры. C ++ предоставляет следующие определяемые пользователем типы данных:
    • Class
    • Structure
    • Union
    • Enumeration
    • Typedef defined DataType

В этой статье обсуждаются примитивных типов данных , доступных в C ++.

  • Целое число : ключевое слово, используемое для целочисленных типов данных, — int . Целые числа обычно требуют 4 байта памяти и находятся в диапазоне от -2147483648 до 2147483647.
  • Символ : Символьный тип данных используется для хранения символов. Ключевое слово, используемое для символьного типа данных — char . Символы обычно требуют 1 байт пространства памяти и находятся в диапазоне от -128 до 127 или от 0 до 255.
  • Boolean : Тип данных Boolean используется для хранения логических или логических значений. Логическая переменная может хранить либо true , либо false . Ключевое слово, используемое для логического типа данных — bool .
  • Floating Point : Тип данных Floating Point используется для хранения значений с плавающей запятой одинарной точности или десятичных значений.Ключевое слово, используемое для типа данных с плавающей запятой, — float . Для переменных с плавающей запятой обычно требуется 4 байта памяти.
  • Double Floating Point : Тип данных Double Floating Point используется для хранения значений с плавающей запятой двойной точности или десятичных значений. Ключевое слово, используемое для типа данных с двойной плавающей запятой, — double . Для переменных типа Double обычно требуется 8 байт памяти.
  • недействителен : Пустота означает отсутствие какого-либо значения. Тип данных void представляет собой бесполезную сущность.Тип данных Void используется для тех функций, которые не возвращают значение.
  • Wide Character : Тип данных Wide character также является символьным типом данных, но этот тип данных имеет размер больше, чем нормальный 8-битный тип данных. В лице wchar_t . Обычно это 2 или 4 байта.


Модификаторы типов данных

Как следует из названия, модификаторы типа данных используются со встроенными типами данных для изменения длины данных, которые может содержать конкретный тип данных. 63) -1 беззнаковый длинный длинный int 8 от 0 до 18,446,744,073,709,551,615 символ со знаком 1 от -128 до 127 символ без знака 1 от 0 до 255 с плавающей запятой двойной 9040 8 long double 12 wchar_t 2 или 4 1 широкий символ

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

CPP

#include

с использованием пространства имен std;

int main ()

{

cout << "Размер символа:" << sizeof ( ) ( )

<< "байт" << endl;

cout << "Размер int:" << sizeof ( int )

<< "" "байт" endl;

cout << "Размер короткого int:" << sizeof ( короткий int )

<< "9000" байт << endl;

cout << "Размер длинного int:" << sizeof ( long int )

<< "9000" байт << endl;

cout << "Размер подписанного long int:" << sizeof ( подписанный long int )

"байтов" << endl;

cout << "Размер длинного целого числа без знака:" << sizeof (без знака long int )

bytes " << endl;

cout << "Размер с плавающей запятой:" << размер ( с плавающей запятой )

<< "байт endl;

cout << "Размер двойного:" << sizeof ( двойной )

<< "" "байт" endl;

cout << "Размер wchar_t:" << sizeof ( wchar_t )

<< "" "" endl;

возврат 0;

}

Вывод:

 Размер символа: 1 байт
Размер int: 4 байта
Размер короткого int: 2 байта
Размер long int: 8 байт
Размер длинного целого числа со знаком: 8 байт
Размер беззнакового длинного целого числа: 8 байт
Размер числа с плавающей запятой: 4 байта
Размер двойного: 8 байт
Размер wchar_t: 4 байта 

Эту статью предоставил Harsh Agarwal .Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью с помощью provide.geeksforgeeks.org или отправить ее по электронной почте на [email protected] Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.
Пожалуйста, напишите комментарий, если вы обнаружите что-то неправильное, или если вы хотите поделиться дополнительной информацией по теме, обсужденной выше.

Вниманию читателя! Не прекращайте учиться сейчас. Присоединяйтесь к курсу First-Step-to-DSA для учащихся 9–12 классов , , специально разработанного для ознакомления со структурами данных и алгоритмами учащихся 9–12 классов


Целочисленные числовые типы - ссылка на C #

  • 4 минуты на чтение

В этой статье

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

Характеристики интегральных типов

C # поддерживает следующие предопределенные целочисленные типы:

От
Тип / ключевое слово C # Диапазон Размер .NET типа
сбайт -128 до 127 8-битное целое число со знаком Система.SByte
байт от 0 до 255 8-битное целое число без знака System.Byte
короткий -32 768 до 32 767 16-битное целое число со знаком System.Int16
ushort 0 до 65 535 16-разрядное целое число без знака System.UInt16
внутренний -2 147 483 648 до 2 147 483 647 32-битное целое число со знаком Система.Int32
uint 0 до 4 294 967 295 32-битное целое число без знака System.UInt32
длинный -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807 64-битное целое число со знаком System.Int64
улонг 0 до 18 446 744 073 709 551 615 64-битное целое число без знака System.UInt64
нинт Зависит от платформы 32-битное или 64-битное целое число со знаком Система.IntPtr
nuint Зависит от платформы 32-битное или 64-битное целое число без знака System.UIntPtr

Во всех строках таблицы, кроме двух последних, каждое ключевое слово типа C # из крайнего левого столбца является псевдонимом для соответствующего типа .NET. Ключевое слово и имя типа .NET взаимозаменяемы. Например, следующие объявления объявляют переменные одного и того же типа:

  int a = 123;
Система.Int32 b = 123;
  

Типы nint и nuint в последних двух строках таблицы являются целыми числами собственного размера. Внутри они представлены указанными типами .NET, но в каждом случае ключевое слово и тип .NET не являются взаимозаменяемыми. Компилятор обеспечивает операции и преобразования для nint и nuint как целочисленные типы, которые он не предоставляет для типов указателей System.IntPtr и System.UIntPtr .Для получения дополнительной информации см. Типы nint и nuint .

Значение по умолчанию для каждого целочисленного типа - ноль, 0 . Каждый из целочисленных типов, кроме типов с собственным размером, имеет константы MinValue и MaxValue , которые обеспечивают минимальное и максимальное значение этого типа.

Используйте структуру System.Numerics.BigInteger для представления целого числа со знаком без верхней или нижней границы.

Целочисленные литералы

Целочисленные литералы могут быть

  • десятичное : без префикса
  • шестнадцатеричный : с префиксом 0x или 0X
  • двоичный : с префиксом 0b или 0B (доступно в C # 7.0 и новее)

Следующий код демонстрирует пример каждого из них:

  var decimalLiteral = 42;
var hexLiteral = 0x2A;
var binaryLiteral = 0b_0010_1010;
  

В предыдущем примере также показано использование _ в качестве разделителя цифр , который поддерживается, начиная с C # 7.0. Вы можете использовать разделитель цифр со всеми видами числовых литералов.

Тип целочисленного литерала определяется его суффиксом следующим образом:

  • Если литерал не имеет суффикса, его тип является первым из следующих типов, в которых может быть представлено его значение: int , uint , long , ulong .

    Примечание

    Литералы интерпретируются как положительные значения. Например, литерал 0xFF_FF_FF_FF представляет число 4294967295 типа uint , хотя он имеет то же битовое представление, что и число -1 типа int . Если вам нужно значение определенного типа, приведите к этому типу литерал. Используйте оператор без флажка , если буквальное значение не может быть представлено в целевом типе. Например, без отметки ((int) 0xFF_FF_FF_FF) дает -1 .

  • Если литерал имеет суффикс U или u , его тип является первым из следующих типов, в которых может быть представлено его значение: uint , ulong .

  • Если литерал имеет суффикс L или l , его тип является первым из следующих типов, в которых может быть представлено его значение: long , ulong .

    Примечание

    В качестве суффикса можно использовать строчную букву l .Однако это генерирует предупреждение компилятора, потому что букву l можно спутать с цифрой 1 . Для ясности используйте L .

  • Если литерал имеет суффикс UL , Ul , uL , ul , LU , Lu , lU или lu , его тип - ulong .

Если значение, представленное целочисленным литералом, превышает UInt64.MaxValue, возникает ошибка компилятора CS1021.

Если определенным типом целочисленного литерала является int , а значение, представленное литералом, находится в диапазоне целевого типа, значение может быть неявно преобразовано в sbyte , byte , short , ushort , uint , ulong , nint или nuint :

  байт a = 17;
байт b = 300; // CS0031: постоянное значение '300' не может быть преобразовано в 'байт'
  

Как показывает предыдущий пример, если значение литерала выходит за пределы диапазона целевого типа, возникает ошибка компилятора CS0031.

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

  var signedByte = (sbyte) 42;
var longVariable = (длинный) 42;
  

преобразования

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

Спецификация языка C #

Дополнительные сведения см. В следующих разделах спецификации языка C #:

См. Также

Типы данных Java: короткие, целые и длинные

Short

В Java тип данных short является самым маленьким типом из трех, которые мы рассмотрим в этом уроке. Это всего 2 байта (16 бит). Как и другие типы данных, он подписан, что означает, что он принимает как отрицательные, так и положительные значения.Из трех типов данных, рассмотренных в этом уроке, это самый маленький. Принимает значения от -32 768 до 32 767.

Вы можете задаться вопросом, почему значения не доходят до 32 768. Это потому, что число 0 должно быть посчитано в диапазоне. И пока мы говорим о нуле:

Значение по умолчанию для short (или int, или long) равно нулю. Это важный момент, который следует запомнить, поскольку вы можете сэкономить место и время, избавившись от необходимости всегда устанавливать переменные в значения (если вы назначите значения позже).

Следующий код Java объявляет две короткие переменные, sn1 и sn2:

 short sn1 = 31000; 
короткий sn2 = -31000;

Хотя это допустимый тип данных, short больше используется для программирования более низкого уровня, такого как обработка изображений или работа с обработкой звука. Это не сильно экономит по сравнению с int (следующая переменная) и на самом деле ничего не дает вам с точки зрения того, как машина использует память для их обработки. Поэтому программисты больше используют int и long.

Int

Следующим по величине типом данных является тип данных int .

В Java переменная, использующая тип данных int, занимает 32 бита в памяти. Int - это целое число (без десятичных знаков), а допустимый диапазон чисел - от -2 147 483 648 до 2 147 483 647.

Отличным вариантом использования типа данных int является возраст: в 99% случаев возраст указывается целиком, положительное значение. Дети скажут вам, что им пять с половиной лет, но большинство программ заботится только о вашем истинном (не дробном) возрасте.Следовательно, объявление age как int обеспечивает выполнение этого правила.

Синтаксис объявления int выглядит следующим образом:

 int customer_age = 18; 

Long

Тип данных Java long может содержать наибольшие целочисленные значения. Он занимает 64 бита памяти и принимает диапазон от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807. Это полезно для хранения чисел, которые перерастают целочисленный тип данных.

При буквальном объявлении переменной, то есть присвоении ей значения, число должно заканчиваться на L или l :

 long long_number1 = 4356334286 L; 
long long_number2 = 834 л;

В предыдущих примерах показаны варианты объявления двух длинных чисел (number1 и number2).Переменные типа Long очень полезны, когда int больше недостаточно для хранения значения. Население мира было бы здесь отличным примером: целое число, но в миллиардах.

Работа с типами данных

Очень важно помнить следующее: вы можете сохранить на , но не на . Это означает, что вы можете сохранить короткое значение в переменной типа int и значение типа int в переменную типа long. Однако вы не можете напрямую сохранить длинную переменную в переменной типа int или short! Это вызовет серьезные ошибки.Если по какой-то причине вы действительно хотите сохранить long в int, работает следующий код:

 long value_1; 
длинное значение_2;
длинное значение_1 = (целое) значение_2;

Предыдущий код приводит к преобразованию как long как int. Он сообщает системе, что вы (думаете), что знаете, что делаете, и можно сохранить это значение из long в int. Однако, если данные будут переполняться, произойдет ошибка! Вы не можете превратить значение 8 000 000 000 000 в int.

Краткое содержание урока

В этом уроке были рассмотрены три типа данных в Java: short , int и long .Это примитивные типы данных, упакованные вместе с языком программирования и готовые к использованию. Каждый тип данных принимает только целые значения, хотя отрицательные значения вполне приемлемы. Короткий размер содержит 2 байта, что делает его наименее полезным для повседневного программирования; int является наиболее распространенным для счетчиков; long содержит большинство целочисленных значений и может использоваться для очень больших чисел (например, для подсчета бактерий в чашке Петри).

(limits.h) - Ссылка C ++

SCHAR_MIN _40 UMX 8 9133 количество байтов в многобайтовом символе для любого языкового стандарта 44
имя выражает возможное значение *
CHAR_BIT Число битов в объекте char (байт) или больше *
SCHAR_MIN Минимальное значение для объекта типа подписанный символ -127 (-2 7 +1 ) или меньше *
Максимальное значение для объекта типа signed char 127 ( 2 7 -1 ) или больше *
UCHAR_MAX Максимальное значение для объекта типа unsigned char 255 ( 2 8 -1 ) или больше *
CHAR_MIN Минимальное значение для объекта типа char 9 0004 либо SCHAR_MIN , либо 0
CHAR_MAX Максимальное значение для объекта типа char либо SCHAR_MAX 844 либо SCHAR_MAX
1 или выше *
SHRT_MIN Минимальное значение для объекта типа short int -32767 9-200013 (3 15 +1 ) или меньше *
SHRT_MAX Максимальное значение для объекта типа short int 32767 ( 2 15 -1 ) или больше *
USHRT_MAX Максимальное значение для объекта типа unsigned short int 65535 ( 2 16 -1 ) или больше *
INT_MIN Минимальное значение для объекта типа int -32767 (-2 15 +1 ) или меньше *
INT_MAX Максимальное значение для объекта типа int 32767 ( 2 15 -1 ) или больше *
UINT значение для объекта типа unsigned int 65535 ( 2 16 -1 ) или выше *
LONG_MIN Минимальное значение для объекта типа long int 905 -2147483647 (-2 31 +1 ) или меньше *
LONG_MAX Максимальное значение для объекта типа long int 2 147483647 ( 2 31 -1 ) или выше *
ULONG_MAX Максимальное значение для объекта типа беззнаковое длинное целое 4294967293 -1000134 ( 4294967293 34 () ) или больше *
LLONG_MIN Минимальное значение для объекта типа long long int -72036854775807 (-2 63 +1 44 905) или меньше * LLONG_MAX Максимальное значение для объекта типа long long int 72036854775807 ( 2 63 -1 ) или больше *
ULLONG значение объекта 8 unsigned long long int 18446744073709551615 ( 2 64 -1 ) или выше *

Базовые типы | Kotlin

В Kotlin все является объектом в том смысле, что мы можем вызывать функции-члены и свойства любой переменной.Некоторые типы могут иметь специальное внутреннее представление - например, числа, символы и логические значения могут быть представлены как примитивные значения во время выполнения - но для пользователя они выглядят как обычные классы. В этом разделе мы описываем основные типы, используемые в Kotlin: числа, логические значения, символы, строки и массивы.

Числа

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

Kotlin предоставляет набор встроенных типов, представляющих числа.
Для целых чисел существует четыре типа с разными размерами и, следовательно, диапазонами значений.

,241
Тип Размер (в битах) Мин. Значение Макс. Значение
Байт 8 -128 127 5 32767
Внутренний 32 -2 147 483 648 (-2 31 ) 2 147 483 647 (2 31 - 1)
Длинный 64-909,809 80844,254 64-909,80 ) 9,223,372,036,854,775,807 (2 63 - 1)

Все переменные, инициализированные целочисленными значениями, не превышающими максимальное значение Int , имеют предполагаемый тип Int .Если начальное значение превышает это значение, то тип - Long . Чтобы явно указать значение Long , добавьте к нему суффикс L .

val one = 1 // Интервал val threeBillion = 3000000000 // Длинный val oneLong = 1L // Длинный val oneByte: Byte = 1

Типы с плавающей запятой

Для вещественных чисел Kotlin предоставляет типы с плавающей запятой Float и Double . Согласно стандарту IEEE 754, типы с плавающей запятой различаются своим десятичным знаком и , то есть количеством десятичных цифр, которые они могут хранить. Float соответствует стандарту IEEE 754 одинарной точности , а Double обеспечивает двойной точности .

Тип Размер (биты) Значащие биты Показательные биты Десятичные цифры
Float 32 2441 840 905 64 53 11 15-16

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

val pi = 3,14 // Двойное значение // val one: Double = 1 // Ошибка: несоответствие типов val oneDouble = 1.0 // Двойное

Чтобы явно указать тип Float для значения, добавьте суффикс f или F . Если такое значение содержит более 6-7 десятичных цифр, оно будет округлено.

значение e = 2.7182818284 // Двойной val eFloat = 2.7182818284f // Float, фактическое значение 2.7182817

Обратите внимание, что в отличие от некоторых других языков, в Kotlin нет неявных расширяющих преобразований для чисел. Например, функция с параметром Double может быть вызвана только для значений Double , но не для Float , Int или других числовых значений.

fun main () { весело printDouble (d: Double) {print (d)} значение я = 1 значение d = 1.0 значение f = 1.0f printDouble (d) // printDouble (i) // Ошибка: несоответствие типа // printDouble (f) // Ошибка: несоответствие типа }

Чтобы преобразовать числовые значения в разные типы, используйте явные преобразования.

Литеральные константы

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

  • Десятичные числа: 123
  • Шестнадцатеричные числа: 0x0F

  • Двоичные файлы: 0b00001011 2

    000

  • не поддерживается.

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

    • Двойные по умолчанию: 123.5 , 123.5e10

    • Плавающие теги f или F : 123.5f

    Чтобы сделать числовые константы более удобочитаемыми, можно использовать символы подчеркивания:

    val oneMillion = 1_000_000 val creditCardNumber = 1234_5678_9012_3456L val socialSecurityNumber = 999_99_9999L val hexBytes = 0xFF_EC_DE_5E val байты = 0b11010010_01101001_10010100_10010010

    Представление чисел в JVM

    На платформе JVM числа хранятся как примитивные типы: int , double и т. Д.Исключениями являются случаи, когда вы создаете ссылку на номер, допускающий значение NULL, например Int? или используйте дженерики. В этих случаях числа заключены в рамки классов Java Integer , Double и так далее.

    Обратите внимание, что обнуляемые ссылки на один и тот же номер могут быть разными объектами:

    fun main () { // sampleStart val a: Int = 100 val boxedA: Int? = а val anotherBoxedA: Int? = а значение b: Int = 10000 val boxedB: Int? = b val anotherBoxedB: Int? = b println (boxedA === anotherBoxedA) // правда println (boxedB === anotherBoxedB) // ложь // sampleEnd }

    Все обнуляемые ссылки на a фактически являются одним и тем же объектом из-за оптимизации памяти, которую JVM применяет к Integer s между -128 и 127 .Это не относится к ссылкам b , так что это разные объекты.

    С другой стороны, они все равно равны:

    fun main () { // sampleStart значение b: Int = 10000 println (b == b) // Выводит true val boxedB: Int? = b val anotherBoxedB: Int? = b println (boxedB == anotherBoxedB) // Выводит true // sampleEnd }

    Явные преобразования

    Из-за различных представлений меньшие типы не являются подтипами больших.Если бы они были, у нас были бы проблемы следующего вида:

    // Гипотетический код, на самом деле не компилируется: val a: Int? = 1 // Упакованный Int (java.lang.Integer) val b: Долго? = a // неявное преобразование дает упакованный Long (java.lang.Long) print (b == a) // Сюрприз! Это печатает "false", так как Equals () Long проверяет, является ли другой также Long.

    Значит, молча потеряли бы равенство, не говоря уже об идентичности.

    Как следствие, меньшие типы НЕ преобразовываются неявно в более крупные типы.Это означает, что присвоение значения типа Byte переменной Int требует явного преобразования.

    fun main () { // sampleStart val b: Byte = 1 // ОК, литералы проверяются статически // val i: Int = b // ОШИБКА значение i1: Int = b.toInt () // sampleEnd }

    Все типы чисел поддерживают преобразование в другие типы:

    • toByte (): Byte
    • toShort (): Short
    • toInt (): Int
    • toLong (): Long
    • toFloat (): Float
    • toDouble (): Double
    • toChar (): Char

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

    val l = 1L + 3 // Long + Int => Long

    Операции

    Kotlin поддерживает стандартный набор арифметических операций над числами: + , - , * , /, % .Они объявляются членами соответствующих классов.

    fun main () { // sampleStart println (1 + 2) println (2_500_000_000L - 1L) println (3,14 * 2,71) println (10.0 / 3) // sampleEnd }

    Вы также можете переопределить эти операторы для пользовательских классов. Подробнее см. Перегрузка оператора.

    Деление целых чисел

    Деление целых чисел всегда возвращает целое число. Любая дробная часть отбрасывается.

    fun main () { // sampleStart значение x = 5/2 // println (x == 2.5) // ОШИБКА: оператор '==' нельзя применить к 'Int' и 'Double' println (x == 2) // sampleEnd }

    Это верно для разделения между любыми двумя целочисленными типами.

    fun main () { // sampleStart значение x = 5L / 2 println (x == 2L) // sampleEnd }

    Чтобы вернуть тип с плавающей запятой, явно преобразуйте один из аргументов в тип с плавающей запятой.

    fun main () { // sampleStart значение x = 5/2. toDouble () println (x == 2,5) // sampleEnd }

    Побитовые операции

    Kotlin предоставляет набор из побитовых операций над целыми числами.Они работают на двоичном уровне напрямую с битами представления чисел. Побитовые операции представлены функциями, которые можно вызывать в инфиксной форме. Их можно применить только к Int и Long .

    val x = (1 shl 2) и 0x000FF000

    Вот полный список побитовых операций:

    • shl (биты) - сдвиг влево со знаком

    • shr (биты) - сдвиг вправо со знаком

    • ushr (биты) - беззнаковый сдвиг вправо

    • и (биты) - побитовые и

    • или (биты) - побитовые или

    • xor (биты) - побитовые xor

    • inv () - побитовая инверсия

    Сравнение чисел с плавающей запятой

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

    • Проверки равенства: a == b и a ! = b

    • Операторы сравнения: a , a> b , a <= b , a> = b

    • Создание экземпляра диапазона a ой диапазон проверок: a..b , x in a..b , x! in a..b

    Когда операнды a и b статически известны как Float или Double или их аналоги, допускающие значение NULL (тип объявлен или выведен или является результатом интеллектуального преобразования), операции над числами и диапазоном, которые они формируют, соответствуют стандарту IEEE 754 для арифметики с плавающей запятой.

    Однако для поддержки общих вариантов использования и обеспечения полного упорядочивания, когда операнды , а не статически типизированы как числа с плавающей запятой (например,грамм. Any , Comparable <...> , параметр типа), в операциях используются реализации equals и compareTo для Float и Double , которые не соответствуют стандарту, так что:

    • NaN считается равным самому себе

    • NaN считается большим, чем любой другой элемент, включая POSITIVE_INFINITY

    • -0.64 - 1

    Типы без знака поддерживают большинство операций своих подписанных аналогов.

    Изменение типа с беззнакового на подписанный аналог (и наоборот) - это изменение , несовместимое с двоичным кодом .

    Беззнаковые массивы и диапазоны

    Беззнаковые массивы и операции с ними находятся в бета-версии. Их можно в любой момент изменить несовместимо. Требуется согласие (подробности см. Ниже).

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

    • UByteArray : массив байтов без знака

    • UShortArray : массив коротких замыканий без знака

    • UIntArray : массив целых чисел без знака

    • ULongArray : массив длинных чисел без знака

    То же, что и для целочисленных массивов со знаком, они предоставляют API, аналогичный классу Array , без накладных расходов на бокс.

    При использовании массивов без знака вы получите предупреждение о том, что эта функция еще нестабильна. Чтобы удалить предупреждение, включите аннотацию @ExperimentalUnsignedTypes . Вам решать, должны ли ваши клиенты явно соглашаться на использование вашего API, но имейте в виду, что неподписанный массив не является стабильной функцией, поэтому API, который их использует, может быть нарушен из-за изменений в языке. Узнайте больше о требованиях к подписке.

    Диапазоны и прогрессии поддерживаются для UInt и ULong классами UIntRange , UIntProgression , ULongRange и ULongProgression .Вместе с беззнаковыми целочисленными типами эти классы стабильны.

    Литералы

    Чтобы упростить использование целых чисел без знака, Kotlin предоставляет возможность пометить целочисленный литерал суффиксом, указывающим на определенный тип без знака (аналогично Float или Long ):

    val b: UByte = 1u // UByte, предусмотрен ожидаемый тип val s: UShort = 1u // UShort, указан ожидаемый тип val l: ULong = 1u // ULong, указан ожидаемый тип val a1 = 42u // UInt: не указан ожидаемый тип, константа подходит для UInt val a2 = 0xFFFF_FFFF_FFFFu // ULong: не указан ожидаемый тип, константа не помещается в UInt

    val a = 1UL // ULong, даже если не указан ожидаемый тип и константа помещается в UInt

    Дальнейшее обсуждение

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

    Boolean

    Тип Boolean представляет логические объекты, которые могут иметь два значения: true и false .

    Boolean имеет аналог, допускающий значение NULL Boolean? , который также имеет значение null .

    Встроенные операции с логическими значениями включают:

    • || - дизъюнкция (логическая ИЛИ )

    • && - конъюнкция (логическая И )

    • ! - отрицание (логическое НЕ )

    || и && работают лениво.

    fun main () { // sampleStart val myTrue: Boolean = true val myFalse: Boolean = false val boolNull: логическое значение? = ноль println (myTrue || myFalse) println (myTrue && myFalse) println (! myTrue) // sampleEnd }

    На JVM : обнуляемые ссылки на логические объекты заключены в рамку аналогично числам.

    Символы

    Символы представлены типом Char . Символьные литералы заключаются в одинарные кавычки: '1' .

    Специальные символы начинаются с обратной косой черты \ . Поддерживаются следующие escape-последовательности: \ t , \ b , \ n , \ r , \ ', \ ", \\ и \ $ .

    Кому кодируйте любой другой символ, используйте синтаксис escape-последовательности Unicode: '\ uFF00' .

    fun main () { // sampleStart val aChar: Char = 'a' println (aChar) println ('\ n') // выводит дополнительный символ новой строки println ('\ uFF00') // sampleEnd }

    Если значением символьной переменной является цифра, вы можете явно преобразовать его в число Int с помощью функции digitToInt () .

    На JVM : Как и числа, символы помещаются в рамку, когда требуется ссылка, допускающая значение NULL. Идентичность не сохраняется при операции бокса.

    Строки

    Строки в Котлине представлены типом String . Как правило, строковое значение представляет собой последовательность символов в двойных кавычках ( ").

    val str =" abcd 123 "

    Элементы строки - это символы, к которым можно получить доступ с помощью операции индексации: s [i] .Вы можете перебирать эти символы с помощью цикла для :

    fun main () { val str = "abcd" // sampleStart for (c in str) { println (c) } // sampleEnd }

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

    fun main () { // sampleStart val str = "abcd" println (ул.uppercase ()) // Создаем и распечатываем новый объект String println (str) // исходная строка остается той же // sampleEnd }

    Для объединения строк используйте оператор + . Это также работает для объединения строк со значениями других типов, если первым элементом выражения является строка:

    fun main () { // sampleStart val s = "abc" + 1 println (s + "def") // sampleEnd }

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

    Строковые литералы

    В Kotlin есть два типа строковых литералов:

    Вот пример экранированной строки:

    val s = "Hello, world! \ N"

    Экранирование выполняется обычным способом, с обратной косой чертой ( \ ). См. В разделе «Символы» список поддерживаемых управляющих последовательностей выше.

    Необработанная строка разделена тройной кавычкой ( "" "), не содержит экранирования и может содержать символы новой строки и любые другие символы:

    val text =" "" for (c in "foo") печать (с) "" "

    Чтобы удалить ведущие пробелы из необработанных строк, используйте функцию trimMargin () :

    val text = "" " | Скажи мне, и я забуду.| Научи меня, и я запомню. | Вовлеките меня, и я узнаю. | (Бенджамин Франклин) "" ".trimMargin ()

    По умолчанию | используется как префикс поля, но вы можете выбрать другой символ и передать его в качестве параметра, например trimMargin (">") .

    Строковые шаблоны

    Строковые литералы могут содержать шаблонов выражений - фрагментов кода, которые оцениваются и результаты которых объединяются в строку. Выражение шаблона начинается со знака доллара ( $ ) и состоит из имени:

    fun main () { // sampleStart val i = 10 println ("i = $ i") // выводит "i = 10" // sampleEnd }

    или выражение в фигурных скобках:

    fun main () { // sampleStart val s = "abc" println ("$ s.length is $ {s.length} ") // выводит" abc.length is 3 " // sampleEnd }

    Шаблоны можно использовать как в необработанных, так и в экранированных строках. Чтобы вставить символ $ в необработанную строку (которая не поддерживает экранирование обратной косой черты) перед любым символом, который разрешен в качестве начала идентификатора, используйте следующий синтаксис:

    val price = "" " $ {'$'} _ 9,99 "" "

    Массивы

    Массивы в Котлине представлены классом Массив . Он имеет get и set функций, которые превращаются в [] в соответствии с соглашениями о перегрузке операторов, и свойство size , а также другие полезные функции-члены:

    class Array private constructor () { размер val: Int оператор fun get (индекс: Int): T набор функций оператора (индекс: Int, значение: T): Unit оператор весело итератор (): Итератор //... }

    Чтобы создать массив, используйте функцию arrayOf () и передайте ей значения элементов, так что arrayOf (1, 2, 3) создает массив [1, 2, 3] . В качестве альтернативы можно использовать функцию arrayOfNulls () для создания массива заданного размера, заполненного пустыми элементами.

    Другой вариант - использовать конструктор Array , который принимает размер массива, и функцию, которая возвращает значения элементов массива по его индексу:

    fun main () { // sampleStart // Создает массив со значениями [«0», «1», «4», «9», «16»] val asc = Массив (5) {я -> (я * я).нанизывать() } asc.forEach {println (it)} // sampleEnd }

    Как было сказано выше, операция [] означает вызовы функций-членов get () и set () .

    Массивы в Котлине инвариантны . Это означает, что Kotlin не позволяет нам назначать массив для массива , что предотвращает возможный сбой во время выполнения (но вы можете использовать Array , см. Проекции типов).

    Массивы примитивных типов

    В Kotlin также есть классы, которые представляют массивы примитивных типов без накладных расходов на упаковку: ByteArray , ShortArray , IntArray и так далее. Эти классы не имеют отношения наследования к классу Array , но имеют тот же набор методов и свойств. У каждого из них также есть соответствующая фабричная функция:

    val x: IntArray = intArrayOf (1, 2, 3) х [0] = х [1] + х [2]

    // Массив int размера 5 со значениями [0, 0, 0, 0, 0] val arr = IntArray (5) // е.

Оставить комментарий

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

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

© 2019 Штирлиц Сеть печатных салонов в Перми

Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми.