About Golang pointer understanding

The following column golang tutorial will introduce to you about Golang pointer understanding. I hope it will be helpful to friends in need!

0x00 Pointer address and pointer type

A variable corresponds to a memory space that stores the value of the corresponding type of the variable. A pointer The value is the address of another variable, and the pointer variable can point to the memory address of any value.

Get address symbol&
Add * before the pointer type to get the content pointed to by the pointer. It is a type changer. Use A pointer referring to a value is called an indirect reference.

prt := &v    // v 的类型为T

v Represents the variable of the fetched address, prt receives the address of v, the type of prt is *T, a pointer type called T.

0x01 Get the value pointed to by the pointer from the pointer

Use & to get the address of the variable to get the pointer of the variable. You can modify the pointer Using the * number to obtain the value pointed to by this pointer is called pointer value acquisition.

temp := "test content"
prt := &temp
fmt.Println(*prt)   // 打印 test content

The relationships and characteristics of variables, pointer addresses, pointer variables, addresses, and values ​​are as follows:

Perform the address (&) operation on a variable to obtain this variable pointer variable.
The value of the pointer variable is the pointer address.
Perform the value (*) operation on the pointer variable to obtain the value of the original variable pointed to by the pointer variable.

0x02 Use a pointer to modify the value

Use * to modify and operate the value pointed to by the pointer

x, y := 1, 2
fmt.Println(x, y)  // 1 2
j, k := &x, &y
*j, *k = *k, *j
fmt.Println(x, y)  // 2 1

* The fundamental meaning of the operator is to operate the variable pointed to by the pointer. When the operation is on an rvalue, it takes the value of the variable pointed to; when the operation is on an lvalue, it sets the value to the variable pointed to.

If only the referenced pointer is exchanged, the referenced variable, value and address will not be affected, only the application pointer will be affected.

x, y := 1, 2
fmt.Println(x, y)  // 1 2
j, k := &x, &y
j, k = k, j
fmt.Println(x, y)    // 1 2
fmt.Printf("x : %p, y :  %p \n", &x, &y)  // x : 0xc00001a088, y :  0xc00001a090
fmt.Printf("j : %p, y :  %p \n", j, k)  //j : 0xc00001a090, y :  0xc00001a088

The values ​​and addresses of x and y are not affected. After the pointers j and k are exchanged, the values ​​of j and k are exchanged.

0x03 Return local variables in the function

In Go language, it is also safe to return the address of local variables in the function. For example, the following code calls f The local variable v is created during the function and is still valid after the local variable address is returned, because the pointer p still refers to this variable

var p = f()

func f() *int {
    v := 1
    return &v
}

0x04 Use new() to create the pointer

	temp := new(int)
	*temp = 123
	fmt.Println(*temp)  // 123
	fmt.Println(temp)  //  0xaabb

0x05 Pointer technology of flag package

Pointer is the key technology to implement the flag package in the standard library. It is used to implement command line flag parsing.
Example:

package main

import (
    "flag"
    "fmt"
    "strings"
)

var n = flag.Bool("n", true, "print test")
var sep = flag.String("s", " ", "separator")
var test = flag.String("test", " ", "测试")

func main() {
    flag.Parse()
    fmt.Println(strings.Join(flag.Args(), *sep))
    if *n {
        fmt.Println(*test)
    }
}

Run

$ go run main.go --help
Usage of /var/exe/main:
  -n	print test
  -s string
    	separator (default " ")
  -test string
    	测试 (default " ")
exit status 2
$ go run main.go -s "+"  --test 测试文本 a bc def 123
a+bc+def+123
$ go run main.go -s "+" -n --test 测试文本 a bc def 123
a+bc+def+123
测试文本

The above is the detailed content of About Golang pointer understanding. For more information, please follow other related articles on the PHP Chinese website!