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 a variable that 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 is nil.

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 is nil.

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 a struct type 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 using interfaces. Therefore, you can see that pointers to structures or interfaces are an essential tool in Go.

7. Pointers as function parameters

Pointers can be used as parameters in

functions . It has some advantages over using values ​​directly. Using pointers as arguments is a 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
}

Using large objects can slow down execution time, here is an example of passing a pointer to a structure. This is an efficient way to handle large objects.

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
}

Be careful when dereferencing structures. If you use it like

*structname.field1 then it will throw error. The correct method is (*structname).field1.

Using pointers inside a function makes the value "

mutable" unless its parameter is const, 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

The

new function 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

You can return pointers of any type from functions just like other values. It's really simple. We don't return the value directly, but the address of the value.

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

Pointers to functions work implicitly in Go. This means we don't need to declare it as a pointer.

package main

import (
    "fmt"
)

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

11. Things to remember when using pointers in Go

Pointer arithmetic is not allowed in Go. Therefore, we cannot perform operations like unary increment or decrement as we can in C/C.

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.

For more programming related knowledge, please visit:

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!