Unsafe code

Unsafe code is Go code that bypasses the type safety and memory security of Go and requires the use of the unsafe package. You will most likely never need to use unsafe code in your Go programs but if for some strange reason you ever need to, it will probably have to do with pointers.

The example code in this subsection is saved as unsafe.go and will be presented in two parts.

The first part is as follows:

package main 
 
import ( 
   "fmt" 
   "unsafe" 
) 
 
func main() { 
   var value int64 = 5

 
   var p1 = &value 
   var p2 = (*int32)(unsafe.Pointer(p1)) 

You first create a new int64 variable that is named value. Then, you create a pointer to it named p1. Next, you create another pointer that points to p1. However, the p2 pointer that points to p1 is a pointer to an int32 integer, despite the fact that p1 points to an int64 variable. Although this is not permitted by Go rules, the unsafe.Pointer() function makes this possible.

The second part is as follows:

   fmt.Println("*p1: ", *p1) 
   fmt.Println("*p2: ", *p2) 
   *p1 = 312121321321213212 
   fmt.Println(value) 
   fmt.Println("*p2: ", *p2) 
   *p1 = 31212132 
   fmt.Println(value) 
   fmt.Println("*p2: ", *p2) 
} 

Executing unsafe.go will create the following output:

$ go run unsafe.go
*p1:  5
*p2:  5
312121321321213212
*p2:  606940444
31212132
*p2:  31212132

The output shows how dangerous an unsafe pointer can be. When the value of the value variable fits into an int32 memory space (5 and 31212132), then p2 works fine and shows the correct result. However, when the value variable holds a value (312121321321213212) that does not fit into an int32 memory space, then p2 shows an erroneous result (606940444), without giving you a warning or an error message.