doujianguang5506 2018-10-02 13:38
浏览 2128
已采纳

如何将[] byte转换为[8] uint8

I need to populate a struct that has a member of type [8]uint8. This needs be populated with a byte array of type []byte initialized to length 8. The simplistic approach does not work:

Data:   [8]uint8(RequestFrame(0x180, r)),

gives

cannot convert .. (type []byte) to type [8]uint8

Since both arrays are structurally identical it would be nice if this could be done with casting/assignment rather than copying?

  • 写回答

2条回答 默认 最新

  • doutuo1908 2018-10-02 14:54
    关注

    Background

    The problem with your "simplistic approach" is that a slice (of any type) is a struct-typed consisting of a pointer and two integers; the pointer contains the address of the underlying (backing) data array, and the integers contain what len() and cap() builtins return for that slice.

    In other words, a slice is sort of a view into an array.

    Then, in Go, there is no concept of a type cast; there are only type conversions, and these conversions may only happen between types with the same underlying representation¹.

    Since a slice and an array may not have the same underlying representation (array is literally a contiguous block of memory of the size just enough to contain all the array's elements), your alleged type conversion may not be legal.

    Possible solutions

    There are two possible solutions.

    The simplest is to just copy the data from the slice's backing array into a newly-allocated array:

    var (
        src = []byte{1, 2, 3, 4, 5, 6, 7, 8}
        dst [8]uint8
    )
    copy(dst[:], src[:8])
    

    Note that there exists an inherent disparity between slice an array types: an array type encodes both the type of its elements and its length (that is, the length is a part of the type), while a slice type only encodes the type of its elements (and may be of any length at runtime).

    This means that you might need to have a check before such copying that makes sure the source slice has exactly 8 elements, that is, len(src) == len(dst).

    This invariant may be enforced by some other code, but I think I'd warn you up front about this: if src has less than 8 elements, the src[:8] expression will panic at runtime, and if it contains more, then there's the question of whether copying just the first 8 of them is exactly what's needed.

    The second approach (admittedly messier) is to just re-use the underlying array of the slice:

    import "unsafe"
    
    var (
        src    = []byte{1, 2, 3, 4, 5, 6, 7, 8}
        dstPtr *[8]uint8
    )
    
    if len(src) != len(*dstPtr) {
        panic("boom")
    }
    dstPtr = (*[8]uint8)(unsafe.Pointer(&src[0]))
    

    Here, we've just taken the address of the first element contained in the slice's underlying array and peformed a "dirty" two-phase type-conversion to make the obtained pointer to be of type *[8]uint8—that is, "an address of an array of 8 uint8s".

    Note two caveats:

    • The resulting pointer now points to the same memory block the original slice does. It means it's now possible to mutate that memory both through the slice and the pointer we obtained.

    • As soon as you'll decide to assign the array's data to a variable of type [8]uint8 (and passing it as an argument to a function's parameter of that type), you will dereference that pointer (like with *dstPtr), and at that moment the array's data will be copied.

      I'm specifically mentioning this as often people resort to hacks like this one to pull the backing array out of a slice precisely in an attempt to not copy the memory.

    TL;DR

    Copy the data (after supposedly verifying the len(src) == len(dst) invariant holds).

    Copying 8 bytes is fast (on a typical 64-bit CPU this will be a single MOV instruction, or two at most), and the code will be straightforward.

    Only resort to hacks from the second solution when you really need to optimize on some critical hot path. In that case, comment the solution extensively and watch for not accidentally dereferencing your pointer.


    ¹ There is a single but notable exception to this rule: a []byte is type-convertible to string, and vice-versa.

    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论
查看更多回答(1条)

报告相同问题?

悬赏问题

  • ¥15 关于#web项目#的问题,请各位专家解答!
  • ¥15 vmtools环境不正常
  • ¥15 请问如何在Ubuntu系统中安装使用microsoft R open?
  • ¥15 jupyter notebook
  • ¥30 informer时间序列预测
  • ¥20 SSR引物多态性分析
  • ¥15 大漠插件在Win11易语言注册调用和免注册灵异事件,VS上注册调用完全没问题
  • ¥15 Addressable缓存机制做热更新的问题
  • ¥15 微信开发者工具vant组件
  • ¥15 iPhone iCloud云盘资料删除,MAC丢失50多G桌面资料