从Golang pkg / net / interface_windows.go了解bytePtrToString（）

I am trying to understand this code to convert from [16]byte to string:

// From: https://code.google.com/p/go/source/browse/src/pkg/net/interface_windows.go
func bytePtrToString(p *uint8) string {
    a := (*[10000]uint8)(unsafe.Pointer(p))
    i := 0
    for a[i] != 0 {
        i++
    }
    return string(a[:i])
}

// Type of ipl.IpAddress.String is [16]byte
str := bytePtrToString(&ipl.IpAddress.String[0])

I mean, what is the reason for the pointer magic? Couldn't it be written simply as follows?

func toString(p []byte) string {
    for i, b := range p {
        if b == 0 {
            return string(p[:i])
        }
    }
    return string(p)
}

// Type of ipl.IpAddress.String is [16]byte
str := toString(ipl.IpAddress.String[:])

No, it could not be written as you propose. You forget what []byte is not array of bytes. Its slice of bytes. In memory slice is just structure which has pointer to buffer (array of bytes, which will hold data) and some information about array size.

a := (*[10000]uint8)(unsafe.Pointer(p))

this code convert byte pointer to array of bytes. In go array of bytes - its just bytes, like in C. Nothing more. So if you will declare array of bytes:

var buffer [256]byte

Go will allocate exactly 256 bytes, array don't even have length. Length of array is part of its type, and only compiler have information about array length. Whats why we can convert byte pointer to array. Its basically the same.

i := 0
for a[i] != 0 {
   i++
}

Here we just find the end of null terminated string.

return string(a[:i])

Here we use slicing operation to create a string. In Go string is basically constant slice, so it will point to the same memory address as original byte pointer.

This two articles will help you understand this topic a bit better: