Why is value changing after function execution?

Question

I'm currently teaching myself Go, and I'm having trouble understanding a certain behavior:

package main

import (
    "fmt"
)

type List struct {
    n int
}

func (l List) Increment() {
    l.n += 1
    l.LogState() // size: 1
}

func (l List) LogState() {
    fmt.Printf("size: %v\n", l.n)
}

func main() {
    list := List{}
    list.Increment()

    fmt.Println("----")
    list.LogState() // size: 0
}

https://play.golang.org/p/-O24DiNPkxx

LogState is executed twice. The initial time, during the Increment call, it prints size: 1 but after Increment has returned it prints size: 0. Why are those values different?

Possible duplicate of stackoverflow.com/questions/28497254/…, stackoverflow.com/questions/24994721/… and more. — user5728991
– user5728991, Commented Oct 14, 2018 at 6:09

Himanshu · Accepted Answer · 2018-10-15 15:49:24Z

The reason your nodes are not added to the original linkedList because you are not using pointer to the struct. So even if the Increment function in your example code changes the value. The copy of the struct is changed not the actual struct.

You can declare methods with pointer receivers. This means the receiver type has the literal syntax *T for some type T. (Also, T cannot itself be a pointer such as *int.)

If you want to change the linkedlistNode struct counter to show the nodes added to the list you should be using a pointer type receiver on both methdos working to modify the linked list as:

func (l *LinkedList) AddInitialValue(v interface{})
func (l *LinkedList) LogState()

And Inside the main pass an address to the linkedList to use those pointer type receivers as:

func main() {
    list :=  &LinkedList{}
    list.AddInitialValue(9)

    fmt.Println("----")
    list.LogState() // size: 0
}

Working Code Go playground

Note:-

There are two reasons to use a pointer receiver.

To modify the value that its receiver points to.

To avoid copying the value on each method call. This can be more efficient if the receiver is a large struct

For more information go through Method Sets

Emin Laletovic · Accepted Answer · 2018-10-14 06:43:20Z

With Increment and LogState defined the way you've defined them, you are working only with the copy of the value of List. This means that if you make some changes inside Increment function, they are visible only inside Increment's function scope and only for the remainder of that particular scope's existence. To confirm you are always working with a copy of of the initial List value, you can log &list before executing Increment function and &l inside the same function.

If you want to make changes permanent, you should work with a pointer to a memory address. That means your your function should be defined like this:

func (l *List) Increment()

func (l *List) LogState()

This way, you are passing a memory reference (pointer to an address in memory) and every time you change a value of l, you are changing it on the passed memory reference and it reflects everywhere.

Collectives™ on Stack Overflow

Why is value changing after function execution?

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related