golang map is not addressable

In Golang, map is a very commonly used data structure. It is an unordered collection of key-value pairs used to store a set of associated data. Although map in Golang is very convenient, it is fundamentally different from ordinary variables, that is, map is not addressable. Let's explore why Golang's map is not addressable.

First, let’s take a look at the definition of map in Golang. Its syntax is as follows:

map[KeyType]ValueType

Among them, KeyType represents the type of key in the map, and ValueType represents the type of value in the map. For example, in the following example, we define a map with keys of string type and values ​​of int type:

var m map[string]int

We can use the make function to initialize a map, for example:

m := make(map[string]int)

Initialization of map The value is nil. If an uninitialized map is used directly for assignment or operation, a run-time error will be triggered.

The storage structure of map in memory is different from arrays and pointers. It is implemented by a hash table. Each key-value pair has a hash value as an index to quickly find data. If the map is addressable, then its hash changes, preventing the data from being looked up quickly, corrupting the map's internal structure.

Moreover, the size of the map changes dynamically, and it can be dynamically expanded or reduced based on adding or deleting key-value pairs. If map is addressable, its internal structure will change, so the designers of Golang disable map addressability.

In addition to map, slices in Golang are also not addressable. This is because the underlying structure of slice is a pointer to an array and a structure with a length value. If the slice can be addressed, the address of the underlying array will change, causing the pointer and length value of the slice to become invalid. Therefore, the designers of Golang Slice addressing is also disabled.

In Golang, if we need to modify the values ​​in the map or slice, we can use indexes or pointers to operate. For example, the following code demonstrates using an index to modify the value in the map:

m := make(map[string]int)
m["a"] = 1
m["b"] = 2
m["c"] = 3

m["a"] = 4
fmt.Println(m) // map[a:4 b:2 c:3]

If you need to modify the value in the slice, you can first obtain a pointer to a certain location in the slice, and then use the pointer to modify it. For example, the following code demonstrates using a pointer to modify the value in a slice:

s := []int{1, 2, 3}
p := &s[1]
*p = 4
fmt.Println(s) // [1 4 3]

In short, in Golang, map and slice are very commonly used data structures, but they are not addressable. If we need to modify one of their values, we can use indexes or pointers to operate. At the same time, you need to pay attention to the underlying implementation of map and slice, as well as their dynamic expansion mechanism.

The above is the detailed content of golang map is not addressable. For more information, please follow other related articles on the PHP Chinese website!