blocks|key|1594785|text|你在传递指向同一片的指针。最后，您将得到一堆指向结果中同一片的指针，因此，所有的值当然都是相同的--它是一次又一次打印的同一个片段。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1594786|还值得注意的是，指向片的指针很少是您想要的，因为切片已经包含了指向基础数组的指针。|1594787|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You're passing around a pointer to the the same slice. In the end you wind up with a bunch of pointers to the same slice in your results, so of course all the values will be identical - it's the same slice printed over and over.

It's also worth noting that a pointer to a slice is rarely what you want, as slices already contain a pointer to the underlying array.

blocks|key|483957|text|不需要指向切片的指针，因为切片本身就是指针。“片是对数组的连续段的引用。”，参考文献。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|483958|您所看到的奇怪行为是因为您正在使用append，当一个片增长到超出其容量时，它需要创建一个具有更大容量的新片，并复制原始片的所有内容(这就是append在幕后所做的)，因此新的切片不再指向原始的基础数组。|483959|与修改传入参数不同，我建议将切片作为函数的返回值返回。|483960|func+permute(nums+[]int)+[][]int+{
+++res+:=+permuteHlp(nums,+0,+new([]int))
+++return+res
}|code-block|syntax|javascript|483961|我建议您阅读golang.org中关于片内件的博客文章，这里|483962|编辑：|483963|我添加了一个重构，采用了这个答案的算法。|483964|package+main

import+(
++++"fmt"++
)

func+permutations(arr+[]int)[][]int{
++++var+helper+func([]int,+int)
++++res+:=+[][]int{}

++++helper+=+func(arr+[]int,+n+int){
++++++++if+n+==+1{
++++++++++++tmp+:=+make([]int,+len(arr))
++++++++++++copy(tmp,+arr)
++++++++++++res+=+append(res,+tmp)
++++++++}+else+{
++++++++++++for+i+:=+0;+i+<+n;+i%2B%2B{
++++++++++++++++helper(arr,+n+-+1)
++++++++++++++++if+n+%25+2+==+1{
++++++++++++++++++++tmp+:=+arr[i]
++++++++++++++++++++arr[i]+=+arr[n+-+1]
++++++++++++++++++++arr[n+-+1]+=+tmp
++++++++++++++++}+else+{
++++++++++++++++++++tmp+:=+arr[0]
++++++++++++++++++++arr[0]+=+arr[n+-+1]
++++++++++++++++++++arr[n+-+1]+=+tmp
++++++++++++++++}
++++++++++++}
++++++++}
++++}
++++helper(arr,+len(arr))
++++return+res
}

func+main()+{
++++x+:=+[]int{1,2,3,4}
++++d+:=+permutations(x)
++++fmt.Print(d)
}|483965|通常，您不希望有指向片的指针，相反，从函数返回一个新的指针，这是另一件需要注释的事情，如果可能的话，尽量不要使用递归，因为golang没有尾调用优化，它的循环执行得非常出色。希望能帮上忙！|483966|entityMap|0|LINK|mutability|MUTABLE|url|https://hackernoon.com/golang-slice-and-append-e18498cf924a|1|https://blog.golang.org/go-slices-usage-and-internals|2|https://stackoverflow.com/a/30226442/5883716^0|12|4|0|0|0|0|0|S|2|1|0|0|C|4|2|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1D|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1E|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|O|3|P|5|6|7|1J|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|S|3|T|5|J|7|1O|8|@]|9|@]|C|$K|L]]|$1|U|3|V|5|6|7|1P|8|@]|9|@]|C|$]]|$1|W|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]|14|$5|Z|10|11|C|$12|15]]|16|$5|Z|10|11|C|$12|17]]]]

There's no need for a pointer to the slice since slices are pointers themselves. "a slice is a reference to a contiguous segment of an array.", <a href="https://hackernoon.com/golang-slice-and-append-e18498cf924a" rel="nofollow noreferrer">reference</a>.

The strange behavior you're seeing is because you're using append, when a slice grows beyond its capacity it's required to create a new slice with increased capacity and copy all the contents of the original one (this is what append does behind the scenes), hence new slice is no longer pointing to the original underlying array.

Instead of modifying the incoming parameter, I suggest returning the slice as a return value for the function.

<pre><code>func permute(nums []int) [][]int {
 res := permuteHlp(nums, 0, new([]int))
 return res
}
</code></pre>

I recommend you read the blog post in golang.org about slices internals, <a href="https://blog.golang.org/go-slices-usage-and-internals" rel="nofollow noreferrer">here</a>

<hr>

Edit:

I add a refactor, taking the algorithm from <a href="https://stackoverflow.com/a/30226442/5883716">this answer</a>.

<pre><code>package main

import (
 "fmt" 
)

func permutations(arr []int)[][]int{
 var helper func([]int, int)
 res := [][]int{}

 helper = func(arr []int, n int){
 if n == 1{
 tmp := make([]int, len(arr))
 copy(tmp, arr)
 res = append(res, tmp)
 } else {
 for i := 0; i &lt; n; i++{
 helper(arr, n - 1)
 if n % 2 == 1{
 tmp := arr[i]
 arr[i] = arr[n - 1]
 arr[n - 1] = tmp
 } else {
 tmp := arr[0]
 arr[0] = arr[n - 1]
 arr[n - 1] = tmp
 }
 }
 }
 }
 helper(arr, len(arr))
 return res
}

func main() {
 x := []int{1,2,3,4}
 d := permutations(x)
 fmt.Print(d)
}
</code></pre>

Generally you won't want to have a pointer to a slice, instead, return a new one from the function, another thing to comment on, try not to use recursion if possible as golang doesn't have tail call optimization, and its loops perform amazingly. Hope it helps!

The following go program is supposed to generate all permutations of a slice of integers:

<pre><code>package main
import "fmt"

func permute(nums []int) [][]int {
 var res [][]int
 var s []int
 permuteHlp(&amp;res, nums, 0, s)
 return res
}

func permuteHlp(res *[][]int, nums []int, i int, s []int) {
 if i == len(nums) {
 *res = append(*res, s)
 return
 }

 for j := i; j &lt; len(nums); j++ {
 s = append(s, nums[j])
 nums[i], nums[j] = nums[j], nums[i]
 permuteHlp(res, nums, i+1, s)
 s = s[:len(s)-1]
 nums[i], nums[j] = nums[j], nums[i]
 }
}

func main() {
 x := []int{1,2,3,4}
 y := permute(x)

 fmt.Println(y)
}
</code></pre>

The output is unexpected

<pre><code>[[1 2 4 3] [1 2 4 3] [1 3 4 2] [1 3 4 2] [1 4 2 3] [1 4 2 3] [2 1 4 3] [2 1 4 3] [2 3 4 1] [2 3 4 1] [2 4 1 3] [2 4 1 3] [3 2 4 1] [3 2 4 1] [3 1 4 2] [3 1 4 2] [3 4 2 1] [3 4 2 1] [4 2 1 3] [4 2 1 3] [4 3 1 2] [4 3 1 2] [4 1 2 3] [4 1 2 3]]
</code></pre>

I don't understand what is wrong here. I would appreciate any help.
Thank you!

Unexpected behavior when passing a pointer to a slice in go

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

下面的go程序应该生成整数片的所有排列：package mainimport "fmt"func permute(nums []int) [][]int {    var res [][]int    var s []int    permuteHlp(&res, nums, 0, s)    return res}f...

问在go中将指针传递到片时的意外行为
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在go中将指针传递到片时的意外行为EN