Using a pointer to array

I'm having a little play with google's Go language, and I've run into something which is fairly basic in C but doesn't seem to be covered in the documentation I've seen so far

When I pass a pointer to a slice to a function, I presumed we'd have some way to access it as follows:

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]
        }
    }
 }

But the Go compiler doesn't like this:

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

Fair enough - it was just a guess. I have got a fairly straightforward workaround:

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]
		}
	}
}

But surely there's a better way. The annoying thing is that googling for info on Go isn't very useful as all sorts of C/C++/unrelated results appear for most search terms.

The Google Go docs state the following about passing arrays - they say you usually want to pass a slice (instead of a pointer?):

Updated:

As indicated by @Chickencha's comment, array slices are references which is why they are efficient for passing. Therefore likely you will want to use the slice mechanism instead of "raw" pointers.

From Google Effective Go doc http://golang.org/doc/effective_go.html#slices
> Slices are reference types,

Original

It's under the heading

An Interlude about Types

> [...snip...] When passing an array
> to a function, you almost always want
> to declare the formal parameter to be
> a slice. When you call the function,
> take the address of the array and Go
> will create (efficiently) a slice
> reference and pass that.

Editor's note: This is no longer the case

Using slices one can write this function (from 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    }

and invoke it like this:

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

Maybe pass the whole array as a slice instead. Google indicates Go deals efficiently with slices. This is an alternate answer to the question but maybe it's a better way.

Types with empty <code>[]</code>, such as <code>[]int</code> are actually slices, not arrays. In Go, the size of an array is part of the type, so to actually have an array you would need to have something like <code>[16]int</code>, and the pointer to that would be <code>*[16]int</code>. So, what you are actually doing already is using slices, and the pointer to a slice, <code>*[]int</code>, is unnecessary as slices are already passed by reference.

<del>Also remember that you can easily pass a slice referring to the entire array with <code>&array</code> (as long as the element type of the slice matches that of the array).</del> (Not anymore.)

Example:

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))
}

Edit: Updated to reflect changes in Go since this was first posted.

The semicolon and the asterisk are added and removed.
> *y[i+j] += x[i]*h[j]

Is interpreted as

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

EDIT: Please read the comments. The answer is probably no longer valid. and I haven't touched up on go for quite some time and can't even read this anymore.

The length is part of the array's type, you can get length of an array by the len() built-in function. So you needn't pass the xlen, hlen arguments.

In Go, you can almost always use slice when passing array to a function. In this case, you don't need pointers.
Actually, you need not pass the y argument. It's the C's way to output array.

In Go style:

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
}

Call the function:

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

Here's a working Go program.

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)
}

To avoid wrong guesses, read the Go documentation: The Go Programming Language.

Almost all the other answers to this question talk about using slices instead of
array pointers but none answers how to solve the error, so I thought I would
write this answer. The error gives us a hint that it cannot access the index of
y because it is an invalid operation.

Your first approach is wrong as the Go compiler shouts at you. The problem in
the first approach is that *y[i+j] is wrong syntax. This is because
technically you are doing this *(y[i+j]) and you can't just do that because
y in your case is a pointer to an int array. If you print y it would print
the memory address of the array.

You are trying to get the i+jth index of y which does not simply exist
because y is not an array. You can fix your code by adding parentheses to the
statement which would indicate that you are trying to get the i+jth index of
the array that y is pointing to. Use (*y)[i+j] instead of *y[i+j]. The
function would look like this after making the changes:

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]
        }
    }
}