How to convert array/slice type in GO without copying?

Question

go

There is a task to write down in a binary file a dial-up of numbers of type float.
It seems like the most correct way with byte order control and other things is this:

d := make([]float32, vectorDataLen)
for x := 0; x < len(d); x++ {
  d[x] = float32(x)
}
var bin_buf bytes.Buffer
binary.Write(&bin_buf, binary.LittleEndian, d)
n, err := dat_file.Write(bin_buf.Bytes())

But in this case, the data is copied once again and the memory is re-allocated, which also seems to be suboptimal.
I tried to play around with the built-in unsafe package:

const SZ = 1000
func test_unsafePointer() {

  d := make([]int, SZ)

  for x := 0; x < len(d); x++ {
    d[x] = x
  }

  p1 := (unsafe.Pointer(&d[0]))

  b := *(*[SZ * unsafe.Sizeof(d[0])]byte)(p1)
  p2 := (unsafe.Pointer(&b[0]))

  s := b[:]
  p3 := (unsafe.Pointer(&s[0]))

  println("len(d)= ", len(d))
  println("len(b)= ", len(b))
  println("len(s)= ", len(s))
  s = append(s, s...)
  p4 := (unsafe.Pointer(&s[0]))
  println("len(s+)= ", len(s))

  println("pointers = ", p1, " ", p2, " ", p3, " ", p4)
}

len(d)= 1000
len(b)= 8000
len(s)= 8000
len(s+)= 16000
pointers = 0xc00006c030 0xc00006a0f0 0xc00006a0f0 0xc000072000

It turns out that the array is "transferred" to the slice without copying, and with the preservation of the functionality of the latter (p2==p3), which is logical when the slice is added, the memory for it is re-allocated: p4 is no longer equal to p3
But how to deal with the re-allocation of d-> b ? p1 != p2

Answer 1

And if at once to write to a file? binary.Write takes the io.Writer interface, after all . So the file opened for writing suits us.

import (
  "encoding/binary"
  "os"
)

func main() {

  dat_file, _ := os.Create("test.txt")
  defer dat_file.Close()

  vectorDataLen := 1000
  d := make([]float32, vectorDataLen)
  for x := 0; x < len(d); x++ {
    d[x] = float32(x)
  }

  binary.Write(dat_file, binary.LittleEndian, d)
}