单变量表达式求值的结果是什么

Question

Running the following snippet of Go code one can realize that function foo receives the value of the first argument actually set while evaluating the second argument of the function. This behavior might look counterintuitive so that we need to prove this to be a part of language spec, not something implementation-specific.

package main

import (
    "fmt"
)

func setVal(s *int, v int) int {
    old := *s
    *s = v
    return old
}

func foo(s int, p int) {
    fmt.Printf("s = %d, p = %d\n", s, p)
}

func main() {
    var s int
    foo(s, setVal(&s, 99))
}

Programm outputs s = 99, p = 0 , which means a modified value of variable s has been passed to the function.

Here is what the Go spec says regarding the case.

In a function call , ...arguments must be single-valued expressions... arguments are evaluated in the usual order. After they are evaluated, the parameters of the call are passed by value to the function... Where usual order is the lexical left-to-right order.

A variable is a storage location for holding a value. ...A variable's value is retrieved by referring to the variable in an expression; it is the most recent value assigned to the variable.

Therefore foo(s, setVal(&s, 99)) is a function call, variable s and function setVal() are the single-valued expressions, and s is evaluated first. The last spec statement makes one assume the result of a variable evaluation is its value, so if that is true, function foo should receive initial value of the variable s .

But it in fact it appears that the function receives the value of the first argument been set at the moment of evaluating the second argument, which is a bit confusing.

Does that mean the evaluation order is broken or the result of a variable evaluation is not its value?

Answer 1

What you "miss" from the spec is Spec: Calls:

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.

Evaluating the parameters does not mean their values are read or "taken". The first parameter is s , its evaluation is s itself, but its value is not yet read. The second parameter is evaluated, which means setVal() is called and will modify the value of s .

Now that we have evaluated the parameters, their values are read, so s will have the value 99 .

Evaluating s in the example is trivial, but of course that could be a more complex expression just like the second argument. Here's a more complex example:

s, s2 := new(int), new(int)

getFunc := func() func(s int, p int) { return foo }
first := func(a, b *int) *int { return a }

getFunc()(*first(s, s2), setVal(s, 99))

Call of the last function involves the following steps:

• function value is evaluated: getFunc() is called, it's return value will be the function value
• parameters are evaluated: (a) first() is called, its return value is dereferenced; (b) setVal() is called, its return value will be used
• And now the values are taken: value of *s and the old value of s (value returned by setVal() ).

This will output the same as your example, try it on the Go Playground .