Nope, that shall be 2 copy-duplicates, one on the parameter enter, one at return worth in primary. I’m referring to the parameter stage. To be exact, listed here are the comparability (with out the return modifications):
func Calculate(i, j int) { // because the perform is named by primary, i, j precise knowledge are duplicated right here as one other set of reminiscence knowledge
...
}
func primary() {
i := 42
j := 2701
Calculate(i, j)
fmt.Printf("After calculate i is: %vn", i) // you WILL get 42 unchanged
fmt.Printf("After calculate j is: %vn", j) // you WILL get 2701 unchanged
}
In comparison with:
func Calculate(i, j *int) { // because the perform is named by primary, i, j pointer knowledge are duplicated right here as one other set of reminiscence knowledge
...
}
func primary() {
i := 42
j := 2701
Calculate(i, j)
fmt.Printf("After calculate i is: %vn", i) // you WONT get 42 however the worth you final modified in Calculate()
fmt.Printf("After calculate j is: %vn", j) // you WONT get 2701 however the worth you final modified in Calculate()
}
Discover that the one with out utilizing pointer, you’ll count on the i and j values in primary stay unchanged however the one utilizing pointer does although primary doesn’t manually modify their values.
In case you’re questioning, for the perform utilizing the pointer enter, the pointer knowledge sort is copied over (pointer itself can be an information) however not the precise knowledge in reminiscence. int knowledge sort is simply too primitive to visualise; think about massive knowledge construction just like the automotive above and you’ll see the revenue.
Similar case, clarify in verbose mode with a guide copy over:
func Calculate(i, j int) (int, int) { // i, j are duplicated as a distinct set of information in reminiscence
m := i / 2 // i seems to be the identical as 4 but it surely's a distinct 4 from primary's i
n := j / 37 // j seems to be the identical as 37 but it surely's a distinct 37 from primary's j
return m, n // return the newly processed values
}
func primary() {
var retI, retJ int
i := 4
j := 37
retI, retJ = Calculate(i, j); // newly processed values saved in retI and retJ
fmt.Println(i); // count on 4 as an alternative of two
fmt.Println(j); // count on 37 as an alternative of 1
fmt.Println(retI); // count on 2
fmt.Println(retJ); // count on 1
i = retI // manually copy over from return worth
j = retJ // manually copy over from return worth
fmt.Println(i); // count on 2
fmt.Println(j); // count on 1
}
As for when GC kicks in, can’t inform until you run your program in opposition to reminiscence profile and tracks GC actions. Nonetheless, m and n are positively launched since they’re extremely more likely to be in stack reminiscence if we converse in C language (can’t assure since Go compiler operates in a different way with out reminiscence profile report). If for unknown motive Go compiler allocates them to heap reminiscence (once more not possible), then they’re for certain GC-ed since they’re not in used.
