golang pointers on pointers as function parameters

Question

I have the following function:

func addCatsToMap(m map[string][]CatHouse, meowId int, treats Set, dog *Dog) {

//if (complicated thing) add Cat to m

}

where Set, the type of treats, is an interface with the following definition:

type Set interface {
  Add(value string)
  Contains(value string) (bool)
  Length() (int)
  RemoveDuplicates()
}

Question:

Is it true that m, treats, and dog are passed-by-reference, and meowId has it's value copied?

I assume that:

m is pass-by-reference because it's a map
dog is a struct. So, I should pass the pointer to avoid copying the data

score 46 · Accepted Answer · answered Jun 21 '12 at 04:06

An interface type is simply a set of methods. Notice that the members of an interface definition do not specify whether or not the receiver type is a pointer. That is because the method set of a value type is a subset of the method set of its associated pointer type. That's a mouthful. What I mean is, if you have the following:

type Whatever struct {
    Name string
}

and you define the following two methods:

func (w *Whatever) Foo() {
    ...
}

func (w Whatever) Bar() {
    ...
}

Then the type Whatever has only the method Bar(), while the type *Whatever has the methods Foo() and Bar(). That means if you have the following interface:

type Grits interface {
    Foo()
    Bar()
}

Then *Whatever implements Grits but Whatever does not, because Whatever lacks the method Foo(). When you define the input to a function as an interface type, you have no idea whether it's a pointer or a value type.

The following example illustrates a function that takes an interface type in both ways:

package main

import "fmt"

type Fruit struct {
    Name string
}

func (f Fruit) Rename(name string) {
    f.Name = name
}

type Candy struct {
    Name string
}

func (c *Candy) Rename(name string) {
    c.Name = name
}

type Renamable interface {
    Rename(string)
}

func Rename(v Renamable, name string) {
    v.Rename(name)
    // at this point, we don't know if v is a pointer type or not.
}

func main() {
    c := Candy{Name: "Snickers"}
    f := Fruit{Name: "Apple"}
    fmt.Println(f)
    fmt.Println(c)
    Rename(f, "Zemo Fruit")
    Rename(&c, "Zemo Bar")
    fmt.Println(f)
    fmt.Println(c)
}

you could call Raname(&f, "Jorelli Fruit") but not Rename(c, "Jorelli Bar"), because both Fruit and *Fruit implement Renamable, while *Candy implements Renable and Candy does not.

http://play.golang.org/p/Fb-L8Bvuwj

Hi, just a quick Q, which method is more efficient? is it stuck to a use case, or we can use the pointer one i.e. *Whatever as our default. (Reason for asking is because I am potently reading Go as a new language for myself and having a hard time to see the pass by value and reference in Go) I have read that everything is pass by value in Go, so if efficiency is the game, do you think * helps? — Yash Tibrewal, Jan 30 '22 at 16:53
don't think about pointer versus value receiver in terms of efficiency, think about it in terms of mutability. use a pointer if the method is going to mutate the object. otherwise use a value receiver. you don't have an efficiency problem until you actually get the code written and profile it and find out you have an efficiency problem. — jorelli, Jan 31 '22 at 22:58
Thanks for the reply @jorelli, I was actually trying to do an database intersection code using go, and the 2 tables are assumed to be very large, hence I asked in terms of efficiency, because lets say I pass by value, I suspect, the same data will be taking memory unto 2 times where else a pointer would help out better. This is just my perspective, I might be wrong. — Yash Tibrewal, Feb 02 '22 at 16:28

Stephen Weinberg · Answer 2 · 2012-06-21T03:47:25.607

Pass by reference is a language thing, nothing in Go is "pass by reference". Pass by reference means the assignment operator can change the original value when use alone. However, there are reference types such as maps and pointers which point somewhere. Using the assignment operator on them will not modify the original unless you use other operators such as the map index and the * operator.

You are correct that your map m is a reference type and therefore like a pointer. Any changes to the map except replacing the map will modify the original.

m["whatever"] = 2           // Modifies the original map
m = anothermap              // Does not modify the original map

If there was true "pass by reference", the second example would modify the original map.

Passing a pointer, as you do with dog allows you to modify the original. If you call any pointer methods or use the * operator, the original will change. In your example, a pointer may not have been needed. If Dog is small, it may be easier to just pass a copy. It is up to the programmer to determine when it is a good time to use a pointer.

Set is not passed by reference. Interfaces are not references. While it is true that internally in the 6g compiler an interface uses pointers, the interface itself does not act like one. Passing an interface, no matter of the size of the object it contains, is as cheap as passing a pointer using the 6g compiler. However, there is no way to modify the original value of an interface as you can with pointers and maps.

Although you can not modify the original interface passed, the interface can contain a pointer type. In that case it would act just like the dog pointer where the calling of certain methods can modify the original. For your particular Set interface, I would guess it contains a pointer type based on the method names. So when you call set.Add(whatever), it will change the internal data of the original.

score 4 · Answer 3 · answered Jun 21 '12 at 17:28

Calls, The Go Programming Language Specification

In a function call, the function value and arguments are evaluated in the usual order. After they are evaluated, the parameters of the call are passed by value to the function and the called function begins execution. The return parameters of the function are passed by value back to the calling function when the function returns.

When are function parameters passed by value? FAQ - The Go Programming Language.

As in all languages in the C family, everything in Go is passed by value. That is, a function always gets a copy of the thing being passed, as if there were an assignment statement assigning the value to the parameter. For instance, passing an int value to a function makes a copy of the int, and passing a pointer value makes a copy of the pointer, but not the data it points to. (See the next section for a discussion of how this affects method receivers.)

Map and slice values behave like pointers: they are descriptors that contain pointers to the underlying map or slice data. Copying a map or slice value doesn't copy the data it points to. Copying an interface value makes a copy of the thing stored in the interface value. If the interface value holds a struct, copying the interface value makes a copy of the struct. If the interface value holds a pointer, copying the interface value makes a copy of the pointer, but again not the data it points to.

golang pointers on pointers as function parameters

3 Answers3

Linked