Detailed explanation of 11 knowledge points about pointers in Go language

Pointers are one of the most important parts of writing good code. In this article, we will explore what pointers are and how to use them in Go.

#1. What is a pointer

A pointer is avariablethat stores the address it points to (emphasis on, Just a variable that stores a numeric value). [Related recommendations:Go Video Tutorial]

A pointer of a specific type can only point to that type (the data type pointed to by the pointer is immutable).

2. GoLang pointer syntax

The syntax of pointers is very simple. Following is the syntax for pointer declaration in Go.

var ptr *type var ptrint *int // 指向 int 的指针

The zero value of a pointer isnil.

3. Initialization of pointers in Go

type pointers are initialized using&:

package main import ( "fmt" ) func main() { var q int = 42 var p *int // declare the pointer p = &q // initialize the pointer fmt.Println(p) // 0x40e020 }

4. Go pointer value

Pointer value means getting the value in the address saved by the pointer. The following is an example of using the*operator to perform pointer value operations:

package main import ( "fmt" ) func main() { var q int = 42 var p *int p = &q fmt.Println(p) // 0x40e020 fmt.Println(*p) // 42 }

5. Pointers to pointers in GoLang

The address of the pointer is a numerical value, and this numerical value can also be assigned to other variables. Therefore, we can create levels of indirection. These levels of indirection can sometimes create unnecessary confusion, so use them with caution.

package main import ( "fmt" ) func main() { i := 64 j := &i // j 是 int 类型的指针 k := &j // k 是存放指针地址的指针，也是 int 类型 fmt.Println(i) // 64 fmt.Println(j) // 0x40e020 fmt.Println(*j) // 64 (value inside that address) fmt.Println(k) // 0x40c138 fmt.Println(*k) // 0x40e020 (address of j) }

6. Pointers to interfaces

Pointers can point to anything, even to interfaces. When using the empty interface, the returned value isnil.

package main import ( "fmt" ) func main() { var a interface{} b := &a fmt.Println(b) // 0x40c138 fmt.Println(*b) // <nil> }

The following is an example of using an interface with pointers.

package main import ( "fmt" ) // 定义接口 type Bird interface{ fly() } type B struct{ name string } // 实现它 func (b B)fly() { fmt.Println("Flying...") } func main() { var a Bird = B{"Peacock"} b := &a fmt.Println(b) // 0x40c138 fmt.Println(*b) // {Peacock} }

Here"a"is astructtype Bird, which is then used for the interface type, as you can see. This is the use of polymorphism. Go allows polymorphism to be achieved usinginterfaces. Therefore, you can see that pointers to structures or interfaces are an essential tool in Go.

7. Pointers as function parameters

functions. It has some advantages over using values directly. Using pointers as arguments isa very efficient way of passing large objects to functions. So using it is a huge optimization.

package main import ( "fmt" ) //声明指针参数 func f(a *int) { fmt.Println(*a) } func main() { var a int = 42 // 传递地址 f(&a) // 42 }

package main import ( "fmt" ) type Human struct { name string age int place string } func f(h *Human) { fmt.Println("The user", (*h).name, "is", (*h).age, "years old and he is from", (*h).place) } func main() { john := Human{"John", 36, "Las Vegas"} f(&john) // The user John is 36 years old and he is from Las Vegas }

*structname.field1then it will throw error.The correctmethod is(*structname).field1.

mutable" unless its parameter isconst, so whenever we want to change a value, We should use a pointer to the value as a function parameter and then modify it as necessary.

8. The "new" function in Go

newfunction in Go returns a pointer to a type.

package main import ( "fmt" ) func main() { ptri := new(int) *ptri = 67 fmt.Println(ptri) // 0x40e020 fmt.Println(*ptri) // 67 }

9. Returning pointers from functions

package main import ( "fmt" ) func p() *int { // 将返回类型指定为指针 v := 101 // 返回地址 return &v } func main() { n := p() fmt.Println(n) // 0x40e020 fmt.Println(*n) // 101 }

10. Pointers to functions

package main import ( "fmt" ) func main() { f := func() { fmt.Println("a function") } pf := f pf() // 一个函数 }

11. Things to remember when using pointers in Go

We might want to use a pointer to an array, but using a slice is a better option. Slices are much more versatile than pointers to arrays. The code is very concise and makes our work easier. Therefore, use slices whenever possible.

Programming Video! !

The above is the detailed content of Detailed explanation of 11 knowledge points about pointers in Go language. For more information, please follow other related articles on the PHP Chinese website!