The selector expression (e.g. x.f) does that: Selectors automatically dereference pointers to structs. If x is a pointer to a struct, x.y is shorthand for (*x).y; if the field y is also a pointer to a struct, x.y.z is shorthand for (*(*x).y).z, and so on. If x contains an anonymous field of type *A, where … Read more
append returns a reference to the appended-to slice. This is because it could point to a new location in memory if it needed to be resized. In your first example, you are updating the variable passed to your setAttribute function, but that’s it. The only reference is lost when that function exits. It works in … Read more
To turn *foo into an interface{} is trivial: f := &foo{} bar(f) // every type implements interface{}. Nothing special required In order to get back to a *foo, you can either do a type assertion: func bar(baz interface{}) { f, ok := baz.(*foo) if !ok { // baz was not of type *foo. The assertion … Read more
When you pass a pointer as an argument, what happens under the hood is that a copy of that pointer is created and passed to the underlying function. It should not be confused with pass-by-reference. Let’s look at an example to better grasp it: package main import ( “fmt” ) type Point struct { x … Read more
Rust usually focuses on object value (i.e. the interesting part of the contents) rather than object identity (memory addresses). The implementation of Display for &T where T implements Display defers directly to the contents. Expanding that macro manually for the String implementation of Display: impl<‘a> Display for &’a String { fn fmt(&self, f: &mut Formatter) … Read more
t := *q makes a copy of the struct pointed to by q. If you want to observe changes to q through t, then stick with a pointer: var ( p = Vertex{1, 2} // has type Vertex q = &Vertex{1, 2} // has type *Vertex r = Vertex{X: 1} // Y:0 is implicit s … Read more
There is no such thing as a “pointer to an interface” (technically, you can use one, but generally you don’t need it). As seen in “what is the meaning of interface{} in golang?”, interface is a container with two words of data: one word is used to point to a method table for the value’s … Read more
Function parameters in Kotlin are basically read-only val‘s inside the function, so z here will always refer to the original object that was passed in. If you need to modify what it points to while your function is running, you’ll have to make a local copy of it at the beginning of the function, and … Read more
In short: you can’t. The error message says: cannot take the address of k There are limitations on the operand of the address operator &. Spec: Address operators: For an operand x of type T, the address operation &x generates a pointer of type *T to x. The operand must be addressable, that is, either … Read more
It’s not possible to get the address (to point) of a constant value, which is why your initialization fails. If you define a variable and pass its address, your example will work. type Config struct { Uri *string } func init() { v := “my:default” var config = Config{ Uri: &v } }