Основы Swift / 2.5. Целые числа


Видео


Целые числа
Целые числа - это рациональные числа без дробной компоненты, такие как 11 или -69. Целые числа могут быть либо знаковыми (положительными, отрицательными или нулём) или беззнаковыми (положительными или нулём).
Swift предоставляет знаковые и беззнаковые целые в 8, 16, 32 и 64-битных формах. Эти целые числа имеют те же соглашения о наименовании, что и в C, что значит, что 8-битовое беззнаковое целое число будет иметь тип UInt8, а 32-битовое знаковое целое иметь тип Int32. Как и все типы в Swift, целые типы имеют название с прописной (заглавной или большой) буквы.
Тип Int
В большинстве случае Вам не нужно использовать конкретный размер целого числа в Вашем коде. Swift предоставляет дополнительный целый тип - Int - который имеет тот же размер, что и размер нативного целого числа текущей платформы:

На 32-битной платформе Int имеет тот же размер, что и Int32.
На 64-битной платформе Int имеет тот же размер, что и Int64.

Пока Вам не потребуется работать с конкретным размером целого числа, всегда используйте Int для целых чисел в Вашем коде. Это даёт Вашему коду переносимость и совместимость. Даже на 32-битных платформах Int может хранить любое значение между -2,147,483,648 и 2,147,483,647; и это значение достаточно большое для многих диапазонов целых чисел.
Ограниченность памяти компьютера
Однако память компьютера не безгранична, а именно её и занимают переменные. Кроме того любой числовой тип имеет ограничения по величине хранимых чисел: например, Вы не сможете хранить в Int32 числа, большие 2,147,483,647 или меньшие -2,147,483,648. Что будет, если попытаться присвоить типу Int32 значение, большее, чем его верхняя граница во время написания кода? Возникнет ошибка во времени компиляции:
@{2.5\1}
                    
var tooLargeInt32: Int32 = 2147483648
                    
                
Нарушение границ
Кроме того может возникнуть ситуация, когда Вы попытаетесь увеличить значение переменной, находящееся на границе допустимых значений, так, что оно выйдет за эти границы. Это выдаст ошибку времени выполнения (так как может быть прибавлено значение из внешнего источника, неконтролируемое на стороне программы, или же, потому что в результате каких-то вычислений, имеющих в себе логическую ошибку, прибавляемое значение стало слишком большим):
@{2.5\2}
                    
var anotherTooLargeInt32: Int32 = 2147483647
let notLarge: Int32 = 1
let thirdTooLargeInt32 = anotherTooLargeInt32 + notLarge
                    
                
Тип UInt
Swift также предоставляет беззнаковый целый тип - UInt - который имеет тот же размер, что и размер нативного целого текущей платформы:

На 32-битной платформе UInt имеет тот же размер, что и UInt32.
На 64-битной платформе UInt имеет тот же размер, что и UInt64.

Используйте UInt, только если он Вам действительно нужен. Если это не так, то предпочтительнее выбирать Int, даже если известно, что хранимые значения будут неотрицательными. Использование Int для целых чисел делает код более переносимым, позволяет избежать нужды конвертировать между различными числовыми типами и совпадает с выведением целых типов.
Нативность
Под нативностью понимается, что нативная сущность является "родной" для чего-либо. В случае с программированием чаще всего это означает, что какой-то объект создан для специально для данной платформы.

Под платформой же понимается совокупность программного и аппаратного обеспечения. В наиболее простом виде это само устройство + операционная система.
Беззнаковость
Что же будет, если попробовать присвоить беззнаковому целому отрицательное значение? Ничего хорошего (а если конкретно, то ошибка времени компиляции):
@{2.5\3}
                    
let soUnsigned: UInt = -1