go语言中切片与内存复制 memcpy 的实现操作_Golang

Go 语言原则上不支持内存的直接操作访问，但是提供了切片功能。

最初我以为切片就是动态数组，实际程序设计过程中发现，切片是提供数组一个内存片段的一个合法的手段，利用切片功能，实际上我们可以自由访问数组的任何一个片段，因而可以借助 copy 函数，实现内存复制。

不同类型之间的数据复制，可以借助 unsafe 取出变量地址，类型转换为数组后，利用数组切片，实现内存复制。

不罗嗦了，示例代码如下：

				?

									package main

									import (

									    "fmt"

									    "unsafe"

									)

									func main() {

									    //数组之间的数据复制

									    var a = [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

									    var b = [10]int{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}

									    copy(a[5:8], b[0:])

									    fmt.Println(a, b)

									    //不同数据类型之间的复制

									    var c uint32 = 0x04030201

									    var d [4]byte

									    p := unsafe.Pointer(&c)

									    q := (*[4]byte)(p)

									    copy(d[0:], (*q)[0:])

									    fmt.Println(d)

									}

运行结果：

[0 1 2 3 4 -1 -1 -1 8 9] [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1]

[1 2 3 4]

补充：go语言之切片复制与追加

看代码吧~

				?

									package main

									import (

									 "fmt"

									)

									func main() {

									 // copy示例

									 // 创建一个新的更大的切片并把原分片的内容都拷贝过来

									 sl_from := []int{1, 2, 3}

									 sl_to := make([]int, 10)

									 n := copy(sl_to, sl_from)

									 fmt.Println("num:", n, "items", sl_to)

									 // append追加元素

									 // append 方法将0个或多个具有相同类型 s 的元素追加到切片后面并且返回新的切片

									 // 追加的元素必须和原切片的元素同类型

									 // 如果 s 的容量不足以存储新增元素，append 会分配新的切片来保证已有切片元素和新增元素的存储

									 sl_a := []int{1, 2, 3}

									 sl_a = append(sl_a, 4, 5, 6)

									 fmt.Println(sl_a)

									 // append 方法追加一个切片

									 var sl_b []int

									 sl_c := []int{1, 2, 3}

									 sl_b = append(sl_b, sl_c...)

									 fmt.Println(sl_b)

									 // 将一个元素快速转为对应切片类型

									 x := 5

									 Test([]int{x})

									}

									func Test(x []int)  {

									 fmt.Println(x)

									}