int16 in Go

In this tutorial, we will learn about the int16 data type in Go. We will cover the basics of defining and using int16 values, including how to perform arithmetic operations and compare 16-bit integers.

Understanding the Int16 Data Type in Go

The int16 data type in Go is used to represent 16-bit signed integer values. The range of an int16 is from -32,768 to 32,767.

Defining an Int16 Variable

Int16 variables in Go can be defined using the var keyword or by type inference with explicit type conversion.

var x int16 = 32000
y := int16(15000)

Performing Arithmetic Operations

Arithmetic operations such as addition, subtraction, multiplication, and division can be performed on int16 values.

sum := x + y
difference := x - y
product := x * y
quotient := x / y

Comparing Int16 Values

Int16 values can be compared using relational operators.

fmt.Println(x > y)
fmt.Println(x < y)
fmt.Println(x == y)

Example 1: Defining and using Int16 Variables

We can define and use int16 variables in Go to represent 16-bit signed integer values.

For example,

  1. Define an int16 variable named x and assign it a value.
  2. Define another int16 variable named y using type inference with explicit type conversion and assign it a value.
  3. Print the values of both int16 variables to the console.

Go Program

package main
import "fmt"
func main() {
    var x int16 = 32000
    y := int16(15000)
    fmt.Println(x)
    fmt.Println(y)
}

Output

32000
15000

Example 2: Performing Arithmetic Operations

We can perform arithmetic operations on int16 values in Go.

For example,

  1. Define two int16 variables named x and y.
  2. Perform addition, subtraction, multiplication, and division on these int16 values.
  3. Print the results of these operations to the console.

Go Program

package main
import "fmt"
func main() {
    x := int16(32000)
    y := int16(15000)
    sum := x + y
    difference := x - y
    product := x * y
    quotient := x / y
    fmt.Println("Sum:", sum)
    fmt.Println("Difference:", difference)
    fmt.Println("Product:", product)
    fmt.Println("Quotient:", quotient)
}

Output

Sum: 47000
Difference: 17000
Product: 480000000
Quotient: 2

Example 3: Comparing Int16 Values

We can compare int16 values in Go using relational operators.

For example,

  1. Define two int16 variables named x and y with different values.
  2. Use relational operators to compare the int16 values and print the results to the console.

Go Program

package main
import "fmt"
func main() {
    x := int16(32000)
    y := int16(15000)
    fmt.Println(x > y)  // true
    fmt.Println(x < y)  // false
    fmt.Println(x == y) // false
}

Output

true
false
false

Example 4: Using Int16 in a Function

We can pass int16 values to functions and return int16 values from functions in Go.

For example,

  1. Define a function named add that takes two int16 parameters and returns their sum.
  2. Call the function with int16 arguments and print the result to the console.

Go Program

package main
import "fmt"
func add(a int16, b int16) int16 {
    return a + b
}
func main() {
    result := add(10000, 15000)
    fmt.Println(result)
}

Output

25000