go特性之数组与切片的问题

数组:
复制传递(不要按照c/c++的方式去理解,c/c++中数组是引用传递),定长

切片:
引用传递,底层实现是3个字段 array(数组) + len(长度) +cap(容量)

go/src/runtime/slice.go slice结构定义:
type slice struct {
	array unsafe.Pointer
	len  int
	cap  int
}

要特别注意的是,切片的引用传递指的是切片传递时,切片的array字段是引用传递的,len和cap字段依然是赋值传递。
写个伪代码:

type Slice struct {
	Array []interface{}
	Len int
	Cap int
}

func fake() {
	slice1 := &Slice{
		Array: 指向一块连续内存的定长数组,
		Len: 0,
		Cap: 4
	}

	slice2 := slice1 // 这一行相当于如下:

	slice2 := &Slice{}
	slice2.Array = slice1.Array // 指向同一块内存,所以说切片是引用传递
	slice2.Len = slice1.Len // len字段被复制了
	slice2.Cap = slice2.Cap // cap字段被复制了

    // 后续如果触发了任一slice的array重新分配内存,另一个slice都是不知道的
	// 已经修改任一slice的len和cap,另一个slice也是不知道的
}

最后总结题

//
//输出结果:
//array1: [1 2 3] array2 [100 2 3]
//slice1: [100 2 3] slice2 [100 2 3]
//
func TestSlice1(t *testing.T) {
	// 数组是赋值传递
	array1 := [3]int{1,2,3}

	// 这里array1复制了一份,array2和array1已经不是同一份数据了
	// 所以对数组array1,array2的修改是互不影响的
	array2 := array1
	array2[0] = 100
	fmt.Println("array1:", array1, "array2", array2)

	// 切片是引用传递
	slice1 := make([]int, 0)
	slice1 = append(slice1, 1, 2, 3)

	// slice2和slice1引用的同一份数据,所以slice2对已有元素的修改,会影响到slice1
	// 这里有个细节需要注意,往下面TestSlice2继续看
	slice2 := slice1
	slice2[0] = 100
	fmt.Println("slice1:", slice1, "slice2", slice2)
}

/*
输出结果
slice1: [1 2 3] slice2 [1 2 3 4]
slice1: [1 2 3] slice2 [1 2 3 4 5]
slice1: [1 2 3] slice2 [100 2 3 4 5]
 */
func TestSlice2(t *testing.T) {
	// 切片是引用传递
	slice1 := make([]int, 0, 4) // 容量是4
	slice1 = append(slice1, 1, 2, 3)

	// slice2和slice1引用的同一份数据,所以slice2对元素的修改,会影响到slice1
	// 特别要注意的是,这里说的引用同一份数据,实际上是指的slice1和slice2内部的ptr指向了同一个数组
	// 但是slice1和slice2结构中的len和cap是复制传递的
	slice2 := slice1
	// 添加第4个元素,容量足够,不会触发内部ptr数组重新分配
	slice2 = append(slice2, 4)
	fmt.Println("slice1:", slice1, "slice2", slice2)

	// 添加第5个元素,容量不足,slice2.ptr重新分配内存,此时slice2.ptr和slice1.ptr已经不是同一份内存了
	slice2 = append(slice2, 5)
	fmt.Println("slice1:", slice1, "slice2", slice2)

	// 所以这里slice2对已有元素的修改,不会影响到slice1了
	slice2[0] = 100
	fmt.Println("slice1:", slice1, "slice2", slice2)
}

到此这篇关于go特性之数组与切片的问题的文章就介绍到这了,更多相关go数组切片内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 理解Golang中的数组(array)、切片(slice)和map

    我比较喜欢先给出代码,然后得出结论 数组 复制代码 代码如下: package main import (     "fmt" ) func main() {     arr := [...]int{1, 2, 3}     //打印初始的指针     fmt.Printf("the pointer is : %p \n", &arr)     printPointer(arr) } func printPointer(any interface{}) {

  • 深入理解Go语言中的数组和切片

    一.类型 数组是值类型,将一个数组赋值给另一个数组时,传递的是一份拷贝. 切片是引用类型,切片包装的数组称为该切片的底层数组. 我们来看一段代码 //a是一个数组,注意数组是一个固定长度的,初始化时候必须要指定长度,不指定长度的话就是切片了 a := [3]int{1, 2, 3} //b是数组,是a的一份拷贝 b := a //c是切片,是引用类型,底层数组是a c := a[:] for i := 0; i < len(a); i++ { a[i] = a[i] + 1 } //改变a的值后

  • GO语言数组和切片实例详解

    本文实例讲述了GO语言数组和切片的用法.分享给大家供大家参考.具体分析如下: 一.数组 与其他大多数语言类似,Go语言的数组也是一个元素类型相同的定长的序列. (1)数组的创建. 数组有3种创建方式:[length]Type .[N]Type{value1, value2, ... , valueN}.[...]Type{value1, value2, ... , valueN} 如下: 复制代码 代码如下: func test5() {     var iarray1 [5]int32    

  • go特性之数组与切片的问题

    数组: 复制传递(不要按照c/c++的方式去理解,c/c++中数组是引用传递),定长 切片: 引用传递,底层实现是3个字段 array(数组) + len(长度) +cap(容量) go/src/runtime/slice.go slice结构定义: type slice struct { array unsafe.Pointer len int cap int } 要特别注意的是,切片的引用传递指的是切片传递时,切片的array字段是引用传递的,len和cap字段依然是赋值传递. 写个伪代码:

  • 对Python 数组的切片操作详解

    高级特性 切片操作:对list,tuple元素进行截取操作,非常简便. L[0:3],L[:3] 截取前3个元素. L[1:3] 从1开始截取2个元素出来. L[-1] 取倒数第一个元素出来. L[-10] 取后10个数 L[10:20] 取前11-20个数 L[:10:2] 取前10个数,每两个取一个 L[::5] 所有数,每5个取一个 L[:] 原样复制一个list tuple,字符串也可以进行切片操作 以上这篇对Python 数组的切片操作详解就是小编分享给大家的全部内容了,希望能给大家一

  • Go数组与切片轻松掌握

    目录 数组(array) 初始化数组 数组赋值 遍历数组 数组对比 切片(slice) 切片的性质 切片初始化 切片赋值 切片的容量 append以及扩容 在 Go 中,数组和切片的功能其实是类似的,都是用来存储一种类型元素的集合.数组是固定长度的,而切片的长度是可以调整的 数组(array) 我们在声明一个数组的时候据必须要定义它的长度,并且不能修改. 数组的长度是其类型的一部分:比如,[2]int 和 [4]int 是两个不同的数组类型. 初始化数组 // 1. 创建一维数组 // 元素都是

  • ES6新特性之数组、Math和扩展操作符用法示例

    本文实例讲述了ES6新特性之数组.Math和扩展操作符用法.分享给大家供大家参考,具体如下: 一.Array Array对象增加了一些新的静态方法,Array原型上也增加了一些新方法. 1.Array.from 从类数组和可遍历对象中创建Array的实例 类数组对象包括:函数中的arguments.由document.getElementsByTagName()返回的nodeList对象.新增加的Map和Set数据结构. //in ES6中 类数组转换为数组的方法 let itemElement

  • 把csv文件转化为数组及数组的切片方法

    在Python中我们经常会用到两个库Numpy和pandas csv文件转化为数组 import numpy my_matrix = numpy.loadtxt(open("c:\\1.csv","rb"),delimiter=",",skiprows=0) //CSV文件转化为数组 将数组或者矩阵存储为csv文件可以使用如下代码实现: numpy.savetxt('new.csv', my_matrix, delimiter = ',') 数组

  • 简单聊一聊Go语言中的数组和切片

    目录 1. 数组 2. 切片(Slice) append 函数 总结 1. 数组 数组是一个由固定长度的特定类型元素组成的序列,一个数组可以由零个或多个元素组成.因为数组的长度是固定的,因此在 Go 语言中很少直接使用数组.和数组对应的类型是 Slice(切片),它是可以增长和收缩的动态序列,slice 功能也更灵活. 数组的每个元素可以通过索引下标来访问,索引下标的范围是从 0 开始到数组长度减 1 的位置.内置的 len 函数将返回数组中元素的个数. var a [3]int // arra

  • 浅谈Go数组比切片好在哪

    目录 数组是什么 切片是什么 数组的优势 可比较 编译安全 长度是类型 规划内存布局 访问速度 总结 参考 前段时间有播放一条快讯,就是 Go1.17 会正式支持切片(Slice)转换到数据(Array),不再需要用以前那种骚办法了,安全了许多. 但是也有同学提出了新的疑惑,在 Go 语言中,数组其实是用的相对较少的,甚至会有同学认为在 Go 里可以把数组给去掉. 数组相较切片到底有什么优势,我们又应该在什么场景下使用呢? 这是一个我们需要深究的问题,因此今天就跟大家一起来一探究竟,本文会先简单

  • 详细介绍Go语言之数组与切片

    目录 一.数组 1.数组的定义 2.数组赋值 3.定义并初始化 4.数组的大小是类型的一部分 5.数组是值类型 6.数组长度 len() 数组长度在定义阶段已经固定 7.数组循环 8.多维数组 9.数组定义并指定位置初始化 二.切片基础 1.切片的定义 2.使用切片 3.修改切片,会影响数组 4.修改数组也会影响切片 5.切片只切数组的一部分 6.当多个切片共用相同的底层数组时,每个切片所做的更改将反应在数组中 7.切片的长度和容量 8.切片追加值 一.数组 数组是同一类型元素的集合,可以放多个

  • golang数组和切片作为参数和返回值的实现

    目录 1. 数组作为参数和返回值时 1.1数组的定义 1.2数组作为参数和返回值的时候 2.切片作为参数和返回值 2.1 切片的定义初始化 2.2 切片的存储大致分为3部分 2.3 切片作为参数和返回值 2.4 append 切片动态增长的原理 2.5 copy 函数 通过赋值切片可以使得两个切片的数据不共享 3. 总结: 1. 数组作为参数和返回值时 1.1数组的定义 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整型.字符串或者自定义类型 var

随机推荐