New to Golang - Confused about pointers, please help to convert c++ snippet to go

I am new to golang, and am slowly learning. To learn I chose to convert this piece of algorithm to golang "http://www.geeksforgeeks.org/backtracking-set-7-suduku/".
I have done my best, but golang pointers confuse more than c++ ones.
I tried a lot of different ways to get it to work but still the pointer stuff keeps getting on my nerves. I just can't get the below mentioned two functions to work properly. Sometimes the output is - no solution found. And sometimes, it just outputs the unchanged grid.
Can someone please fix the SolveSudoku() and FindUnassignedLocation() functions (and anything else, if any) and explain how to use references and pointers in GO.
I also tried reading some documentation on the GO website but that isn't that great really and I am not experienced enough to understand the extremely small stuff given there.
I will also be grateful if someone suggests a few more things that can be improved in this code, bugs? , errors?, anything.

package main
import "fmt"
const (
UNASSIGNED = 0
N          = 9
)
func SolveSudoku(grid [N][N]int) bool {
var row, col int
if !FindUnassignedLocation(grid, row, col) {
return true
}
for num := 1; num <= 9; num++ {
if isSafe(grid, row, col, num) {
grid[row][col] = num
if SolveSudoku(grid) {
return true
}
grid[row][col] = UNASSIGNED
}
}
return false
}
func FindUnassignedLocation(grid [N][N]int, row int, col int) bool {
for row = 0; row < N; row++ {
for col = 0; col < N; col++ {
if grid[row][col] == UNASSIGNED {
return true
}
}
}
return false
}
func UsedInRow(grid [N][N]int, row int, num int) bool {
for col := 0; col < N; col++ {
if grid[row][col] == num {
return true
}
}
return false
}
func UsedInCol(grid [N][N]int, col int, num int) bool {
for row := 0; row < N; row++ {
if grid[row][col] == num {
return true
}
}
return false
}
func UsedInBox(grid [N][N]int, boxStartRow int, boxStartCol int, num int) bool {
for row := 0; row < 3; row++ {
for col := 0; col < 3; col++ {
if grid[row+boxStartRow][col+boxStartCol] == num {
return true
}
}
}
return false
}
func isSafe(grid [N][N]int, row int, col int, num int) bool {
return !UsedInRow(grid, row, num) && !UsedInCol(grid, col, num) && !UsedInBox(grid, row-row%3, col-col%3, num)
}
func printGrid(grid [N][N]int) {
for row := 0; row < N; row++ {
for col := 0; col < N; col++ {
fmt.Printf("%2d", grid[row][col])
}
fmt.Printf("\n")
}
}
func main() {
var grid = [N][N]int{
[N]int{3, 0, 6, 5, 0, 8, 4, 0, 0},
[N]int{5, 2, 0, 0, 0, 0, 0, 0, 0},
[N]int{0, 8, 7, 0, 0, 0, 0, 3, 1},
[N]int{0, 0, 3, 0, 1, 0, 0, 8, 0},
[N]int{9, 0, 0, 8, 6, 3, 0, 0, 5},
[N]int{0, 5, 0, 0, 9, 0, 6, 0, 0},
[N]int{1, 3, 0, 0, 0, 0, 2, 5, 0},
[N]int{0, 0, 0, 0, 0, 0, 0, 7, 4},
[N]int{0, 0, 5, 2, 0, 6, 3, 0, 0},
}
if SolveSudoku(grid) == true {
printGrid(grid)
} else {
fmt.Printf("No solution exists")
}
return
}

Your issue isn't really that you don't understand pointers. Pointers mostly work the same way in Go as in C++ (except since Go has things like escape analysis and GCs you don't have to worry about dangling or invalid pointers, at the dubious cost of no pointer arithmetic).

Your issue is a misunderstanding in the difference between an array in C++ and Go. In C++ an array is literally a pointer, the syntax is an alias. Doing int a[9] and int *a are the same type, the static sizing and free initialization is just a cool compiler trick. Accessing an array is fancy syntax for pointer arithmetic followed by a dereference -- which, as mentioned, is something Go doesn't have.

In Go, arrays are values rather than pointers. When you have a function that takes a [9]int you're literally telling the compiler to copy nine integer values, rather than a pointer to a location in memory that happens to have nine integer values. Think of func(a [2]int) as being a nice way to write func(a1, a2 int).

This also leads to another subtle code difference, in C++ int a[9][9] is a pointer to nine pointers to nine ints each. In Go it's a literal, contiguous RMO stored block of 9x9 integers.

There are two simple solutions in Go:

1. Use a pointer to an array. As in grid *[N][N]int. This works fine, but it's a bit unclean to access and store things in the array. You'll have to use (*grid)[i][j] to explicitly dereference the pointer which looks ugly and can be a bit hard to read.

2. Use slices. This is the better option, and more idiomatic Go style. It also avoids that nasty global constant being all over the place. The tradeoff is that you do sacrifice some a priori guarantees about the sizing of the columns.

I'll rewrite a couple methods with a slice with a couple comments and leave the rest to you:

func main() {
// We can omit the []int on every line, Go infers it
var grid = [][]int{
{3, 0, 6, 5, 0, 8, 4, 0, 0},
{5, 2, 0, 0, 0, 0, 0, 0, 0},
{0, 8, 7, 0, 0, 0, 0, 3, 1},
{0, 0, 3, 0, 1, 0, 0, 8, 0},
{9, 0, 0, 8, 6, 3, 0, 0, 5},
{0, 5, 0, 0, 9, 0, 6, 0, 0},
{1, 3, 0, 0, 0, 0, 2, 5, 0},
{0, 0, 0, 0, 0, 0, 0, 7, 4},
{0, 0, 5, 2, 0, 6, 3, 0, 0},
}
// == true is superfluous
if SolveSudoku(grid) {
printGrid(grid)
} else {
fmt.Println("No solution exists")
}
// Don't need to explicitly return, Go's mains are "void"
}
func UsedInCol(grid [][]int, col int, num int) bool {
// We can use range to iterate over the whole slice.
// The first value (which we ignore) is the slice index, the value you
// used to call "row".
// Now row is the slice containing the given row, this is similar to an iterator.
for _,row := range grid {
if row[col] == num {
return true
}
}
return false
}

Miscellaneous notes:

1. Where you used the constant N before, you can now use len(grid). To get the length of a column, use len(grid[0]) (warning: make sure grid[0] exists).

2. Due to it being a value, having a [N][N]int as an argument or return value is almost always inefficient because it's a rather large copy on every function call. Pointer chasing is usually faster, except for very small values of N (maybe 1-2).

3. References don't exist in Go, except in extremely technical senses like the behavior of closed-over variables.

4. An even better way to do this may be to declare something like type SudokuGrid struct { grid []int; rows,cols int } with some sort of At/Set method set, which lets you have some sizing guarantees back. I'll leave doing this (or whether it's even a good idea) up to you.