使用指向数组的指针

Question

我正在玩 google 的 Go 语言，我遇到了一些 C 语言中相当基本的东西，但我目前看到的文档中似乎没有涉及

当我将指向切片的指针传递给函数时，我认为我们有一些方法可以访问它，如下所示：

func conv(x []int, xlen int, h []int, hlen int, y *[]int)

    for i := 0; i<xlen; i++ {
        for j := 0; j<hlen; j++ {
            *y[i+j] += x[i]*h[j]
        }
    }
 }

但是 Go 编译器不喜欢这样：

sean@spray:~/dev$ 8g broke.go
broke.go:8: invalid operation: y[i + j] (index of type *[]int)

很公平 - 这只是一个猜测。我有一个相当简单的解决方法：

func conv(x []int, xlen int, h []int, hlen int, y_ *[]int) {
    y := *y_

    for i := 0; i<xlen; i++ {
        for j := 0; j<hlen; j++ {
            y[i+j] += x[i]*h[j]
        }
    }
}

但肯定有更好的方法。烦人的是，在 Go 上搜索信息并不是很有用，因为大多数搜索词都会出现各种 C/C++/不相关的结果。

Answer 1

Google Go 文档 state the following about passing arrays - 他们说您通常想要传递切片（而不是指针？）：

更新：

正如@Chickencha 的评论所指出的，数组切片是引用，这就是它们有效传递的原因。因此，您可能希望使用切片机制而不是“原始”指针。

来自 Google Effective Go 文档 http://golang.org/doc/effective_go.html#slices

切片是引用类型，

---

原创

在标题下

关于类型的插曲

[...snip...] 传递数组时 对于一个函数，你几乎总是想要 将形参声明为 一片。当你调用函数时， 获取数组的地址并执行 将（有效地）创建一个切片 参考并通过。

编者注：不再是这种情况

使用切片可以编写这个函数（来自 sum.go）：

09    func sum(a []int) int {   // returns an int
10        s := 0
11        for i := 0; i < len(a); i++ {
12            s += a[i]
13        }
14        return s
15    }

并像这样调用它：

19        s := sum(&[3]int{1,2,3})  // a slice of the array is passed to sum    

---

也许将整个数组作为切片传递。谷歌表示 Go 可以有效地处理切片。这是该问题的替代答案，但也许是更好的方法。

Answer 2

[] 为空的类型，例如 []int，实际上是切片，而不是数组。在 Go 中，数组的大小是类型的一部分，所以要真正拥有一个数组，你需要有类似[16]int 的东西，指向它的指针是*[16]int。因此，您实际上已经在使用切片，并且指向切片的指针*[]int 是不必要的，因为切片已经通过引用传递。

还请记住，您可以使用 &array 轻松传递一个引用整个数组的切片（只要切片的元素类型与数组的元素类型匹配）。（现在不行了。）

例子：

package main
import "fmt"

func sumPointerToArray(a *[8]int) (sum int) {
    for _, value := range *a { sum += value }
    return
}
func sumSlice (a []int) (sum int) {
    for _, value := range a { sum += value }
    return
}
func main() {
    array := [...]int{ 1, 2, 3, 4, 5, 6, 7, 8 }
    slice := []int{ 1, 2, 3, 4 }
    fmt.Printf("sum arrray via pointer: %d\n", sumPointerToArray(&array))
    fmt.Printf("sum slice: %d\n", sumSlice(slice))
    slice = array[0:]
    fmt.Printf("sum array as slice: %d\n", sumSlice(slice))
}

编辑：更新以反映自首次发布以来 Go 的变化。

Answer 3

添加和删除分号和星号。

*y[i+j] += x[i]*h[j]

被解释为

(*y)[i+j] += x[i] * h[j];

编辑：请阅读 cmets。答案可能不再有效。而且我已经有一段时间没有接触到 go 了，甚至无法再阅读此内容了。

Answer 4

长度是数组类型的一部分，可以通过内置函数len()获取数组的长度。所以你不需要传递 xlen、hlen 参数。

在 Go 中，您几乎总是可以在将数组传递给函数时使用 slice。在这种情况下，您不需要指针。 实际上，您不需要传递 y 参数。这是C的输出数组的方式。

Go 风格：

func conv(x, h []int) []int {
    y := make([]int, len(x)+len(h))
    for i, v := range x { 
        for j, u := range h { 
            y[i+j] = v * u 
        }   
    }   
    return y
}

调用函数：

conv(x[0:], h[0:])

Answer 5

这是一个正在运行的 Go 程序。

package main

import "fmt"

func conv(x, h []int) []int {
    y := make([]int, len(x)+len(h)-1)
    for i := 0; i < len(x); i++ {
        for j := 0; j < len(h); j++ {
            y[i+j] += x[i] * h[j]
        }
    }
    return y
}

func main() {
    x := []int{1, 2}
    h := []int{7, 8, 9}
    y := conv(x, h)
    fmt.Println(len(y), y)
}

为避免错误猜测，请阅读 Go 文档：The Go Programming Language.

Answer 6

这个问题的几乎所有其他答案都在谈论使用切片而不是 数组指针，但没有人回答如何解决错误，所以我想我会 写下这个答案。该错误提示我们它无法访问 y 因为这是一个无效的操作。

您的第一种方法是错误的，因为 Go 编译器对您大喊大叫。问题在 第一种方法是 *y[i+j] 是错误的语法。这是因为 从技术上讲，你正在这样做*(y[i+j])，你不能这样做，因为 y 在您的情况下是指向 int 数组的指针。如果您打印y，它将打印 数组的内存地址。

您正在尝试获取不存在的y 的i+jth 索引 因为y 不是数组。您可以通过在 表示您正在尝试获取的 i+jth 索引的语句 y 指向的数组。使用(*y)[i+j] 而不是*y[i+j]。这 进行更改后，函数将如下所示：

func conv(x []int, xlen int, h []int, hlen int, y *[]int) {
    for i := 0; i<xlen; i++ {
        for j := 0; j<hlen; j++ {
            (*y)[i+j] += x[i]*h[j]
        }
    }
}