2 ms·
No, there is a real difference, this is not splitting hairs. Go is always pass-by-value, even for maps [0]: x := map[int]int{1: 2} foo(x) fmt.Printf("%+
by tsimionescu 2y ago
No, there is a real difference, this is not splitting hairs.
Go is always pass-by-value, even for maps [0]:
x := map[int]int{1: 2}
foo(x)
fmt.Printf("%+v", x) //prints map[1:2]
func foo(a map[int]int) {
a = map[int]int{3: 4}
}
In contrast, C++ references have different semantics [1]:
std::map<int, int> x {{1, 2}};
foo(x);
std::print("{%d:%d}", x.begin()->first, x.begin()->second);
//prints {3:4}
void foo(std::map<int, int>& a) {
a = std::map<int, int> {{3, 4}};
}
[0] https://go.dev/play/p/6a6Mz9KdFUh https://go.dev/play/p/6a6Mz9KdFUh
[1] https://onlinegdb.com/j0U2NYbjL https://onlinegdb.com/j0U2NYbjL
- erik_seaberg 2y agofoo is receiving a mutable reference and it can't modify the map without those changes leaking out permanently to the caller: https://go.dev/play/p/DXchC5Hq8o8 https://go.dev/play/p/DXchC5Hq8o8. Passing maps by value would have prevented this by copying the contents. It's a quirk of C++ that reference args can't be replaced but pointer args can.
- tsimionescu 2y agoThe point is that the local variable referencing the map is a different entity than the map itself. Foo gets a copy of that local variable, and the copy references the same map object. And the fact that C++ references can be used for assignment is essentially their whole point, not "a quirk".