Разное

Float int double: В чем разница int, long и float, double? — Хабр Q&A

Содержание

Встроенные числовые преобразования — справочник по C#



  • Чтение занимает 3 мин

В этой статье

C# предоставляет набор целочисленных типов и типы с плавающей запятой.C# provides a set of integral and floating-point numeric types. Существует преобразование между любыми двумя числовыми типами: неявное или явное.There exists a conversion between any two numeric types, either implicit or explicit. Для выполнения явного преобразования необходимо использовать выражение приведения.You must use a cast expression to perform an explicit conversion.

Неявные числовые преобразованияImplicit numeric conversions

В следующей таблице приведены предопределенные неявные преобразования между встроенными числовыми типами:The following table shows the predefined implicit conversions between the built-in numeric types:

Исходный типFrom КомуTo
sbytesbyte short, int, long, float, double или decimalshort, int, long, float, double, or decimal
bytebyte short, ushort, int, uint, long, ulong, float, double или decimalshort, ushort, int, uint, long, ulong, float, double, or decimal
shortshort int, long, float, double или decimalint, long, float, double, or decimal
ushortushort int, uint, long, ulong, float, double или decimalint, uint, long, ulong, float, double, or decimal
intint long, float, double или decimallong, float, double, or decimal
uintuint long, ulong, float, double или decimallong, ulong, float, double, or decimal
longlong float, doubleили decimalfloat, double, or decimal
ulongulong float, doubleили decimalfloat, double, or decimal
floatfloat double

Примечание

Неявные преобразования из int, uint, long или ulong в float и из long или ulong в double могут приводить к потере точности, но не к потере порядка величин. The implicit conversions from int, uint, long, or ulong to float and from long or ulong to double may cause a loss of precision, but never a loss of an order of magnitude. Другие неявные числовые преобразования никогда не теряют никаких сведений.The other implicit numeric conversions never lose any information.

Также обратите внимание на следующее.Also note that

  • Любой целочисленный тип неявно преобразуется в любой числовой тип с плавающей запятой.Any integral numeric type is implicitly convertible to any floating-point numeric type.

  • Не поддерживается неявное преобразование в типы byte и sbyte.There are no implicit conversions to the byte and sbyte types. Не поддерживается неявное преобразование из типов double и decimal.There are no implicit conversions from the double and decimal types.

  • Не поддерживается неявное преобразование между типом decimal и типами float или double.There are no implicit conversions between the decimal type and the float or double types.

  • Значение константного выражения типа int (например, значение, представленное целочисленным литералом) может быть неявно преобразовано в sbyte, byte, short, ushort, uint или ulong, если оно находится в диапазоне целевого типа:A value of a constant expression of type int (for example, a value represented by an integer literal) can be implicitly converted to sbyte, byte, short, ushort, uint, or ulong, if it’s within the range of the destination type:

    byte a = 13;
    byte b = 300;  // CS0031: Constant value '300' cannot be converted to a 'byte'
    

    Как показано в предыдущем примере, если значение константы выходит за пределы диапазона целевого типа, возникает ошибка компилятора CS0031. As the preceding example shows, if the constant value is not within the range of the destination type, a compiler error CS0031 occurs.

Явные числовые преобразованияExplicit numeric conversions

В следующей таблице показаны предопределенные явные преобразования между встроенными числовыми типами, для которых нет неявного преобразования:The following table shows the predefined explicit conversions between the built-in numeric types for which there is no implicit conversion:

Исходный типFrom КомуTo
sbytesbyte byte, ushort, uint или ulongbyte, ushort, uint, or ulong
bytebyte sbyte
shortshort sbyte, byte, ushort, uint или ulongsbyte, byte, ushort, uint, or ulong
ushortushort sbyte, byteили shortsbyte, byte, or short
intint sbyte, byte, short, ushort, uint или ulongsbyte, byte, short, ushort, uint, or ulong
uintuint sbyte, byte, short, ushort или intsbyte, byte, short, ushort, or int
longlong sbyte, byte, short, ushort, int, uint или ulongsbyte, byte, short, ushort, int, uint, or ulong
ulongulong sbyte, byte, short, ushort, int, uint или longsbyte, byte, short, ushort, int, uint, or long
floatfloat sbyte, byte, short, ushort, int, uint, long, ulong или decimalsbyte, byte, short, ushort, int, uint, long, ulong, or decimal
doubledouble sbyte, byte, short, ushort, int, uint, long, ulong, float или decimalsbyte, byte, short, ushort, int, uint, long, ulong, float, or decimal
decimaldecimal sbyte, byte, short, ushort, int, uint, long, ulong, float или doublesbyte, byte, short, ushort, int, uint, long, ulong, float, or double

Примечание

Явное числовое преобразование может привести к утрате данных или созданию исключения, обычно OverflowException. An explicit numeric conversion might result in data loss or throw an exception, typically an OverflowException.

Также обратите внимание на следующее.Also note that

  • При преобразовании значения целочисленного типа в другой целочисленный тип результат зависит от переполнения контекста проверки.When you convert a value of an integral type to another integral type, the result depends on the overflow checking context. В проверенном контексте преобразование выполняется успешно, если исходное значение находится в диапазоне конечного типа.In a checked context, the conversion succeeds if the source value is within the range of the destination type. В противном случае возникает исключение OverflowException.Otherwise, an OverflowException is thrown. В непроверяемом контексте преобразование всегда завершается успешно и выполняется следующим образом.In an unchecked context, the conversion always succeeds, and proceeds as follows:

    • Если исходный тип больше целевого, исходное значение усекается путем отбрасывания его «лишних» самых значимых битов.If the source type is larger than the destination type, then the source value is truncated by discarding its «extra» most significant bits. Результат затем обрабатывается как значение целевого типа.The result is then treated as a value of the destination type.

    • Если исходный тип меньше целевого, исходное значение дополняется знаками или нулями, чтобы иметь тот же размер, что и целевой тип.If the source type is smaller than the destination type, then the source value is either sign-extended or zero-extended so that it’s of the same size as the destination type. Знаки добавляются, если исходный тип имеет знак. Если у исходного типа нет знака, добавляются нули.Sign-extension is used if the source type is signed; zero-extension is used if the source type is unsigned. Результат затем обрабатывается как значение целевого типа.The result is then treated as a value of the destination type.

    • Если исходный тип совпадает по размеру с целевым, исходное значение обрабатывается как значение целевого типа. If the source type is the same size as the destination type, then the source value is treated as a value of the destination type.

  • При преобразовании значения decimal в целочисленный тип оно округляется в сторону нуля до ближайшего целого значения.When you convert a decimal value to an integral type, this value is rounded towards zero to the nearest integral value. Если итоговое целое значение находится вне диапазона целевого типа, возникает исключение OverflowException.If the resulting integral value is outside the range of the destination type, an OverflowException is thrown.

  • При преобразовании значения double или float в целочисленный тип оно округляется в сторону нуля до ближайшего целого значения.When you convert a double or float value to an integral type, this value is rounded towards zero to the nearest integral value. Если полученное целое значение выходит за пределы диапазона целевого типа, результат будет зависеть от контекста проверки переполнения.If the resulting integral value is outside the range of the destination type, the result depends on the overflow checking context. В проверенном контексте возникает исключение OverflowException, а в непроверенном контексте результатом будет неопределенное значение целевого типа.In a checked context, an OverflowException is thrown, while in an unchecked context, the result is an unspecified value of the destination type.

  • При преобразовании из double в float значение double округляется до ближайшего значения float.When you convert double to float, the double value is rounded to the nearest float value. Если значение double слишком мало или слишком велико для типа float, результатом будет ноль или бесконечность соответственно.If the double value is too small or too large to fit into the float type, the result is zero or infinity.

  • При преобразовании из float или double в decimal исходное значение преобразуется в представление decimal и при необходимости округляется до ближайшего числа после 28-го десятичного разряда.When you convert float or double to decimal, the source value is converted to decimal representation and rounded to the nearest number after the 28th decimal place if required. В зависимости от исходного значения возможны следующие результаты:Depending on the value of the source value, one of the following results may occur:

    • Если исходное значение слишком мало для представления в виде decimal, результатом будет ноль.If the source value is too small to be represented as a decimal, the result becomes zero.

    • Если исходное значение не является числом (NaN), равно бесконечности или слишком велико для представления в виде decimal, возникает исключение OverflowException.If the source value is NaN (not a number), infinity, or too large to be represented as a decimal, an OverflowException is thrown.

  • При преобразовании из decimal в float или double исходное значение округляется до ближайшего значения float или double соответственно.When you convert decimal to float or double, the source value is rounded to the nearest float or double value, respectively.

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

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:For more information, see the following sections of the C# language specification:

См. такжеSee also

Преобразование типов при присваивании | Программирование на C и C++

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

int х;
char ch;
float f;

void func(void)
{
ch = х; /*    1    */
х = f;    /*    2    */
f = ch;  /*    3    */
f = x;    /*    4    */
}

В строке 1 левые, старшие, биты целочисленной переменной х обрубаются, оставляя в ch младшие 8 битов. Если х содержит число между 256 и 0, то ch и х будут иметь одинаковое значение Иначе значение ch будет содержать только младший набор битов переменной х. В строке 2 х получает целую часть переменной f. В строке 3 f получает 8-битное целое число, хранящееся в ch преобразованное к формату с плавающей точкой. В строке 4 f получает значение целочисленной переменной х, преобразованное к формату с плавающей точкой.

Когда происходит преобразование из целого числа к символу, из длинного целого — к целому и из целого — к короткому целому, то старшие биты будут потеряны. Когда используется 16-битное целое, это означает, что 8 бит будут потеряны при преобразовании от целого к символу и 16 бит будут потеряны при преобразовании от длинного целого к целому.

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

Таблица: Обычные результаты преобразования типов
Целевой тип Исходный тип Возможные потери информации
signed char unsigned char Если значение > 127, то результат станет отрицательным числом
char short int Старшие 8 бит
char int (16 бит) Старшие 8 бит
char int (32 бита) Старшие 24 бита
short int int (16 бит) Нет
short int int (32 бита) Старшие 16 бит
int (16 бит) long int Старшие 16 бит
int (32 бита) long int Нет
float double Точность, результат округляется
double long double Точность, результат округляется

  1.  Преобразование из int в float или из float в double и тому подобное не добавляет точности. Такого рода преобразования только изменяют формат представления значения.
  2. Некоторые компиляторы С (и процессоры) всегда трактуют переменные типа char как положительные, независимо от того, какое значение было при преобразовании к целому или плавающему типам. Другие компиляторы могут трактовать переменную типа char как знаковую, где числа, большие, чем 127, трактуются как отрицательные (как делает Borland С++). В целом следует использовать переменные типа char для символов, a int, short int или signed char когда необходимо избежать проблем с переносимостью.

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

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

Что означают int, float, double, char, bool.​

помогите пожалуйста ​

присоединенные территории при Ольгерде​

Нужен ответ с решением!! Срочно! Даю 80б!!!!помогите пожалуйста!!! ​

Привет ! Как имея под рукой ucb вывести с телефона на телевизор изображение. Хочу посмотреть фильмы =/Телевизор:TOSHIBA2013 — 069Aug 03 2013​

Где все эпитеты и метафоры
В. Ґете «Нічна пісня подорожнього»
На гірських вершинах
Спить сніг.
Вітерець в долинах
Затих.
Тиша без краю, безмеж.
Змовкн

ув пташиний галас.
Почекай — зараз
Ти заснеш теж.

Задача № 2 К Вам в аптеку поступили следующие ЛП: бициллин-1 во флаконах по 1200000 ЕД, кетоконазол в таблетках по 0, 2 г, ацикловир в виде 5 % мази в

тубах по 5 г. Задание: 1. Разделите эти препараты по спектру их химиотерапевтического действия. 2. Объясните механизм действия препаратов. Укажите, с чем связана избирательность химиотерапевтического действия каждого из препаратов. 3. Перечислите и обоснуйте показания к применению препаратов с учетом лекарственной формы. 4. Перечислите побочные эффекты препаратов. Задача № 3 К провизору безрецептурного отдела аптеки («первого стола») обратился пациент со следующей рецептурной прописью: Rp.: Doxycyclini hydrochloridi 0,05 D.t.d. № 20 in capsulis S. По 2 капсулы 2 раза в сутки. # Rp.: Nystatini 250000 ED D.t.d. № 30 in tabulettis S. Внутрь по 1 таблетке 2 раза в сутки. Задание: 1.Укажите, к каким группам химиотерапевтических средств относятся выписанные в рецепте препараты. 2.Объясните, с какой целью врач назначил данную комбинацию. 3.Объясните механизм действия препаратов. Укажите, с чем связана избирательность химиотерапевтического действия каждого из препаратов. 4.Назовите показания к применению Доксициклина и Нистатина. 5.Проинформируйте пациента о возможных побочных эффектах, вызванных применением Доксициклина. Задача № 4 К провизору «первого стола» обратился пациент со следующей рецептурной прописью: Rp.: Azytromycini 0,25 D.t.d. № 20 in capsulis S. Внутрь по 2 капсулы 2 раза в сутки. # Rp.: Chloramphenicoli 0,25 D.t.d. № 30 in tab. S. Внутрь по 1 таблетке 3 раза в сутки. Задание: 1.Укажите, к каким группам антибактериальных средств относятс

Задача № 2 К Вам в аптеку поступили следующие ЛП: бициллин-1 во флаконах по 1200000 ЕД, кетоконазол в таблетках по 0, 2 г, ацикловир в виде 5 % мази в

тубах по 5 г. Задание: 1. Разделите эти препараты по спектру их химиотерапевтического действия. 2. Объясните механизм действия препаратов. Укажите, с чем связана избирательность химиотерапевтического действия каждого из препаратов. 3. Перечислите и обоснуйте показания к применению препаратов с учетом лекарственной формы. 4. Перечислите побочные эффекты препаратов. Задача № 3 К провизору безрецептурного отдела аптеки («первого стола») обратился пациент со следующей рецептурной прописью: Rp. : Doxycyclini hydrochloridi 0,05 D.t.d. № 20 in capsulis S. По 2 капсулы 2 раза в сутки. # Rp.: Nystatini 250000 ED D.t.d. № 30 in tabulettis S. Внутрь по 1 таблетке 2 раза в сутки. Задание: 1.Укажите, к каким группам химиотерапевтических средств относятся выписанные в рецепте препараты. 2.Объясните, с какой целью врач назначил данную комбинацию. 3.Объясните механизм действия препаратов. Укажите, с чем связана избирательность химиотерапевтического действия каждого из препаратов. 4.Назовите показания к применению Доксициклина и Нистатина. 5.Проинформируйте пациента о возможных побочных эффектах, вызванных применением Доксициклина. Задача № 4 К провизору «первого стола» обратился пациент со следующей рецептурной прописью: Rp.: Azytromycini 0,25 D.t.d. № 20 in capsulis S. Внутрь по 2 капсулы 2 раза в сутки. # Rp.: Chloramphenicoli 0,25 D.t.d. № 30 in tab. S. Внутрь по 1 таблетке 3 раза в сутки. Задание: 1.Укажите, к каким группам антибактериальных средств относятс

Что вреднее 1) микробы 2) молоко.​

Складіть діалог Вільяма Леграна та Шерлока Холмса про методи їхнього розслідування.
или
Складіть діалог доктора Ватсона та Джупітера про свого господа

ря та компаньйона та методи їхніх розслідувань.

яке було значення книгодрукування для розвитку європейської культури​

Типы данных float и double в языке программирования Java / Программирование / ADODO.ru

Простые, или примитивные, типы данных — это встроенные в язык Java типы, аналогичные типам данных большинства языков программирования. Эти типы могут применяться самостоятельно или используются как составные части более сложных типов данных, которые создают программисты.

Java позволяет использовать 8 простых типов данных:

byte, short, int, long – целочисленные,

float, double — вещественные обычной и двойной точности,

boolean — булевские (логические, представляющие истину или ложь),

сhar — символьные, представляющие символы Unicode.

Float и double применяются для выполнения инженерных и научных расчетов.

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

Выбор между float и double делают, исходя из необходимой точности представления данных.

Тип double содержит почти вдвое больше значащих цифр, чем float, и больший диапазон показателя степени.

В вещественных данных три части — знак s (равен 1 или -1) мантисса m и порядок p. Числа представлены в двоичной системе. Мантисса m хранит значащие цифры числа. Произведение мантиссы и основания системы, возведенного в степень, равную порядку, дает истинную величину числа s.

С вещественными данными можно выполнять обычные арифметические операции (+-*/), результат которых — тоже вещественное число. Сравнение действительных данных выполняется операциями <, >, <=, >=, ==, != (меньше, больше, не больше, не меньше, равно, не равно). Следует проявлять внимательность при сравнении действительных данных и действительных литералов, поскольку действительные данные представляются с погрешностью.

Каждому простому типу в языке Java соответствует объектный тип — так называемый класс-оболочка (wrapper class). Классы-оболочки (для float и double это Float и Double) содержат полезные и интересные методы для проверок свойств данных или для их преобразования в другие типы.

Подробная информация о классах-оболочках имеется в документации по Java.

Основные типы | Kotlin

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

Числа

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

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

Тип Размер (биты) Мин. Значение Макс. Значение
Байт 8 -128 127
Короткий 16 -32768 32767
Внутренний 32 -2 147 483 648 (-2 31 ) 2 147 483 647 (2 31 — 1)
Длинный 64 -9 223 372 036 854 775 8052 (-2 63 ) 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 24 8 6-7
Double 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 десятичных цифр, оно будет округлено.

val 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

  • Двоичные числа: 0b2060000109

    Двоичные числа: 0b2060000109 не поддерживается.

    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
    }

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

    fun main () {
    // sampleStart
    val a: Int = 10000
    println (a == a) // выводит true
    val boxedA: Int? = а
    val anotherBoxedA: Int? = а
    println (boxedA == anotherBoxedA) // выводит 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 nd диапазон проверок: a. 64 - 1

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

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

    Беззнаковые типы реализуются с использованием еще нестабильной функции, а именно встроенных классов.

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

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

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

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

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

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

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

    Кроме того, диапазоны и прогрессии поддерживаются для 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

    Бета-статус беззнаковых целых чисел

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

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

    • . Чтобы распространить требование согласия, аннотируйте объявления, использующие беззнаковые целые числа, с помощью @ExperimentalUnsignedTypes .

    • Чтобы подписаться без распространения, либо аннотируйте объявления с помощью @OptIn (ExperimentalUnsignedTypes :: class) , либо передайте -Xopt-in = kotlin.ExperimentalUnsignedTypes компилятору.

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

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

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

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

    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 number:

    fun decimalDigitValue (c: Char): Int {
    если (c! в '0'..'9 ')
    throw IllegalArgumentException ("За пределами допустимого диапазона")
    return c.toInt () - '0'.toInt () // Явное преобразование в числа
    }

    На 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 (ул.toUpperCase ()) // Создаем и распечатываем новый объект String
    println (str) // исходная строка остается той же
    // sampleEnd
    }

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

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

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

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

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

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

    val s = "Hello, world! \ N"

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

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

    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

    оператор fun iterator (): Iterator
    //...
    }

    Чтобы создать массив, используйте функцию 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 , см. 5 * 0 +.2

    Однако компьютер не может сохранить это: у него нет явного метода выражения этой двоичной точки (версия десятичной точки в двоичной системе счисления). Компьютер может хранить только единицы и нули. Здесь на помощь приходит тип данных с плавающей запятой.

    Предполагая, что sizeof (float) составляет 4 байта, у вас всего 32 бита. Первому биту назначается «знаковый бит». Нет беззнаковых чисел с плавающей запятой или двойных чисел. Следующие 8 битов используются для «экспоненты», а последние 23 бита используются как «мантисса» (или иногда называемая мантиссой).1, и наше значение было бы 1.111.

    Если первый бит равен 1, число отрицательное. Если нет, то положительно. Показатель степени изменяется так называемым «смещением», поэтому мы не можем просто сохранить «0000 0010» в качестве показателя степени. Смещение для числа с плавающей запятой одинарной точности составляет 127, а смещение для двойной точности (именно здесь тип данных double и получает свое имя) составляет 1023. Последние 23 бита зарезервированы для мантиссы. Мантисса - это просто значения СПРАВА от нашей двоичной точки.

    Наша экспонента будет представлять собой смещение (127) + показатель (1) или представлена ​​в двоичном формате

      1000 0000
      

    Наше значение будет:

      111 0000 0000 0000 0000 0000
      

    Следовательно, 3,75 представляется как:

      0100 0000 0111 0000 0000 0000 0000 0000
      

    Теперь давайте посмотрим на число 8, представленное как число с плавающей запятой и как целое число:

      0100 0001 0000 0000 0000 0000 0000 0000 0000
    0000 0000 0000 0000 0000 0000 0000 1000
      

    Как вообще компьютер прибавит 8.0 и 8? Или даже умножить их !? Компьютеры (точнее, компьютеры x86) имеют разные части ЦП, которые добавляют числа с плавающей запятой и целые числа.

    базовых типов данных в Python - настоящий Python