Тип int16
Тип int16 в Go представляет 16-разрядное целое число со знаком.
Он занимает 2 байта (16 бит) памяти и может хранить значения
в диапазоне от -32768 до 32767. Этот тип часто используется
для экономии памяти при работе с небольшими числами,
а также при взаимодействии с внешними системами,
где требуется строго определенный размер данных.
Диапазон значений
Тип int16 имеет фиксированный диапазон значений.
Давайте выведем минимальное и максимальное значение
с помощью констант пакета math:
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("Min: %d\n", math.MinInt16)
fmt.Printf("Max: %d\n", math.MaxInt16)
}
Результат выполнения кода:
"Min: -32768"
"Max: 32767"
Как видно из примера, int16 может хранить числа
в указанном диапазоне. Попытка присвоить значение
выходящее за пределы диапазона приведет к ошибке
на этапе компиляции или переполнению.
Объявление переменной
Переменную типа int16 можно объявить несколькими
способами: явно указав тип, с помощью короткой записи,
или с использованием литералов разных систем счисления:
package main
import "fmt"
func main() {
var num1 int16 = 10000
num2 := int16(5000)
var num3 int16
hexNum := int16(0x7FFF)
octNum := int16(077777)
fmt.Println(num1)
fmt.Println(num2)
fmt.Println(num3)
fmt.Println(hexNum)
fmt.Println(octNum)
}
Результат выполнения кода:
"10000"
"5000"
"0"
"32767"
"32767"
Обратите внимание, что переменная num3 получает
нулевое значение по умолчанию для типа int16.
Арифметические операции
С типом int16 можно выполнять все стандартные
арифметические операции: сложение, вычитание,
умножение, деление и взятие остатка:
package main
import "fmt"
func main() {
a := int16(100)
b := int16(25)
res1 := a + b
res2 := a - b
res3 := a * b
res4 := a / b
res5 := a % b
fmt.Println(res1)
fmt.Println(res2)
fmt.Println(res3)
fmt.Println(res4)
fmt.Println(res5)
}
Результат выполнения кода:
"125"
"75"
"2500"
"4"
"0"
При выполнении арифметических операций важно помнить,
что результат не должен выходить за пределы диапазона
значений типа int16.
Переполнение
При выходе за пределы допустимого диапазона возникает переполнение. В Go переполнение для целочисленных типов происходит без предупреждения, значение "зацикливается":
package main
import "fmt"
func main() {
var num int16 = 32767
num++
fmt.Println(num)
}
Результат выполнения кода:
"-32768"
Как видите, при увеличении максимального значения на единицу происходит переход к минимальному значению. Аналогично происходит при выходе за минимальное значение.
Преобразование типов
Тип int16 можно преобразовывать к другим
целочисленным типам с помощью явного приведения.
Важно следить, чтобы значение помещалось в целевой тип:
package main
import "fmt"
func main() {
var a int16 = 1000
b := int32(a)
c := int(a)
d := int8(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
}
Результат выполнения кода:
"1000"
"1000"
"232"
При преобразовании int16 в int8 происходит
обрезание старших битов, что может привести к неожиданным
результатам, как в примере выше.
Сравнение чисел
Значения типа int16 можно сравнивать между собой
с использованием операторов сравнения:
package main
import "fmt"
func main() {
a := int16(100)
b := int16(200)
c := int16(100)
fmt.Println(a == b)
fmt.Println(a != b)
fmt.Println(a < b)
fmt.Println(a > b)
fmt.Println(a <= b)
fmt.Println(a >= b)
fmt.Println(a == c)
}
Результат выполнения кода:
"false"
"true"
"true"
"false"
"true"
"false"
"true"
Операторы сравнения возвращают логическое значение
bool и позволяют проверять отношения между числами.
Работа с вводом-выводом
Тип int16 часто используется для чтения данных
из бинарных файлов или сетевых протоколов, где требуется
строго определенный размер. Пример чтения числа из
байтового среза:
package main
import (
"encoding/binary"
"fmt"
)
func main() {
bytes := []byte{0x01, 0x00}
num := binary.LittleEndian.Uint16(bytes)
numInt16 := int16(num)
fmt.Printf("Bytes: %v\n", bytes)
fmt.Printf("Uint16: %d\n", num)
fmt.Printf("Int16: %d\n", numInt16)
}
Результат выполнения кода:
"Bytes: [1 0]"
"Uint16: 1"
"Int16: 1"
Для корректной работы с бинарными данными используйте
пакет encoding/binary, который позволяет
контролировать порядок байтов.
