Преобразование числовых данных

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

1
2
3
4
var a: Int8 = 10
var b: Int8 = 8
var c: Int8 = a + b
print(c) // 18
Однако в силу различных причин не всегда операнды представляют один и тот же тип. И также не всегда тип переменной или константы, которой присваивается результат операции, совпадает с типом операндов. И в подобных случаях необходимо выполнять преобразования типов.

Если операнды операций представляют числовые литералы, которые относятся к разным типам, то Swift автоматически выполняет преобразование:

1
2
let x = 10/3.0
print(x) // 3.33333333333333
В данном случае числовой литерал 10 представляет тип Int, а 3.0 - тип Double. В этом случае первый литерал преобразуется к типу Double, и выполняется деление.

Однако если операнды представляют константы или переменные или являются результатами каких-то других операций или выражений, то в этом случае нам нужно явно выполнять преобразование типов. Для этого применяются специальные функции-инициализаторы типов данных. Все они совпадают с названиями типов данных: Int8(), Int(), Float(), Double() и т.д. Так, функция Double() преобразует значение к типу Double, а в скобки передается само значение. Например:

1
2
3
let d = 8 // представляет тип Int
let g = Double(d) // преобразуем в тип Double
print(g) // 8.0
При этом мы не можем напрямую передать значение типа int переменной типа Double, несмотря на то, что вроде бы обе переменных после преобразования все равно содержат фактически число 8:

1
2
let d = 8 // представляет тип Int
let g: Double = d // ! Ошибка - разные типы
То есть в данном случае нам обязательно надо использовать явное преобразование типов: let g = Double(d)

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

1
2
3
let n = 10
let d = 3.0
let x = n / d // ошибка компиляции
Чтобы код заработал, используем явное приведение типов:

1
2
3
let n = 10
let d = 3.0
let x = Double(n) / d // x = 3.3333333333
В данном случае значение константы n преобразуется в Double, и так как константа d также представляет тип Double, то ошибки не возникнет, а константа x также будет представлять тип Double.

Либо мы могли бы преобразовать второй операнд к типу Int:

1
2
3
let n = 10
let d = 3.0
let x = n / Int(d) // x = 3
Так как оба операнда теперь представляют тип Int, то и константа x будет представлять Int и будет равна 3.

Другой пример: сумма значений Int8 присваивается переменной типа Int32, то есть отличается тип операндов от типа результата:

1
2
3
var a: Int8 = 10
var b: Int8 = 10
var c: Int32 = a + b // Error
Здесь результатом операции является значение типа Int8, так как оба операнда представляют этот тип. И несмотря на то, что это целое число, мы не можем его просто присвоить переменной типа Int32. Необходимо выполнить преобразование типов:

1
2
3
var a: Int8 = 10
var b: Int8 = 10
var c: Int32 = Int32(a) + Int32(b)
В этом случае переменный a и b преобразуются к типу Int32.