golang changes pointer pointing

Golang is an open source programming language that is efficient, scalable, and easy to learn. It is widely used in network applications, distributed systems, cloud computing, artificial intelligence and other fields.

In Golang, pointer is a very common data type. It is used to store the address of a variable in memory, allowing the program to directly access and modify the value of the variable. Pointers in Golang can obtain the address of a variable through the & operator, and indirectly access the value of the variable using the * operator.

However, in some cases, we may need to change the pointer's pointer while the program is running, that is, from the address of one variable to the address of another variable. This usually occurs in programs that involve dynamically allocated memory or data structure operations. In this article, we will explore how to change pointer pointing in Golang.

Assignment of pointers

First, let's look at a simple example to demonstrate how to use pointers to change the value of a variable.

package main
  
import "fmt"
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var p *int           // 声明一个整型指针p
  
    p = &a               // 将指针p指向变量a的地址
    *p = 20              // 通过指针p，修改a的值为20
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
}

In the above code, we declare an integer variable a and initialize it to 10. At the same time, a pointer p pointing to an integer is declared and pointed to the address of the variable a through the & operator. Next, we use *p to get the value of the variable pointed to by pointer p and modify it to 20, thus changing the value of variable a.

Redirection of pointers

In the above example, we modified the value of variable a through pointer p, but did not change the pointer of pointer p itself. Now, let's take a look at how to redirect a pointer so that it points to the address of another variable.

package main
  
import "fmt"
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p *int           // 声明一个整型指针p
  
    p = &a               // 将指针p指向变量a的地址
    p = &b               // 将指针p重定向为变量b的地址
  
    fmt.Println("a = ", a) // 输出a的值，结果为10
    fmt.Println("b = ", b) // 输出b的值，结果为20
    fmt.Println("*p = ", *p) // 输出*p所指向变量的值，结果为20
}

In the above code, we declare two integer variables a and b and initialize them to 10 and 20 respectively. At the same time, a pointer p pointing to an integer is declared. Next, we use &p to point the pointer p to the address of variable a, and then redirect it to the address of variable b.

When we output the values ​​of a and b, we find that their values ​​have not changed, and through *p we can access the value of variable b, which is 20.

Exchange of pointers

The exchange of pointers refers to exchanging the addresses of variables pointed to by two pointers to achieve the purpose of exchanging variable values. In this section, we will introduce two methods to implement pointer exchange.

Method 1: Exchange through temporary variables

package main
  
import "fmt"
  
func swap(a, b *int) {
    var temp int        // 定义一个临时变量temp
    temp = *a
    *a = *b
    *b = temp
}
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p1 *int = &a      // 声明一个指向变量a的指针p1
    var p2 *int = &b      // 声明一个指向变量b的指针p2
  
    swap(p1, p2)          // 交换指针p1和p2所指向变量的值
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
    fmt.Println("b = ", b) // 输出b的值，结果为10
}

In the above code, we define a swap function that accepts two pointers to int types. In this function, we define a temporary variable temp to store the value of the variable pointed to by one of the pointers. Then, we exchange the value of the variable through the pointer, and finally realize the exchange of pointers.

Method 2: Swap through pointer to pointer

package main
  
import "fmt"
  
func swap(a **int, b **int) {
    var temp *int         
    temp = *a
    *a = *b
    *b = temp
}
  
func main() {
    var a int = 10        // 声明一个变量a，并初始化为10
    var b int = 20        // 声明一个变量b，并初始化为20
    var p1 *int = &a      // 声明一个指向变量a的指针p1
    var p2 *int = &b      // 声明一个指向变量b的指针p2
  
    swap(&p1, &p2)        // 交换指针p1和p2的指向
  
    fmt.Println("a = ", a) // 输出a的值，结果为20
    fmt.Println("b = ", b) // 输出b的值，结果为10
}

In the above code, we modified the signature of the swap function so that it accepts two pointers to pointers. In this way, in the swap function, we can exchange the pointing of these two pointers, thereby realizing the exchange of pointers.

Summary

This article mainly introduces the method of changing the pointer pointing in Golang. Through the explanation of this article, we can understand how to use pointers to change the value of a variable, redirect the pointer to point, and exchange the value of the variable pointed to by the pointer.

We need to be very careful when using pointers, because incorrect use of pointers may cause program crashes or data corruption. Therefore, we must read the code carefully and always use pointers with caution.

The above is the detailed content of golang changes pointer pointing. For more information, please follow other related articles on the PHP Chinese website!