Learning Golang from scratch: exploring the secrets of pointers

Learn Golang from scratch: Exploring the mysteries of pointers

In the process of learning programming languages, pointers are a very important and often overlooked concept. In the Go language, pointers are also a very useful data type. Pointers can effectively manage memory, transfer data, and improve program performance and efficiency. This article will start from scratch and explore the mysteries of pointers in the Go language step by step through specific code examples.

What is a pointer

In the Go language, a pointer is a data type that stores the memory address of a variable. Through pointers, you can directly operate on the memory space where the variable is located instead of operating on the variable itself. The pointer uses the & operator to obtain the address of the variable, and the * operator is used to access the variable pointed to by the pointer.

Create pointer variables

In Go language, you can use * to declare a pointer variable, for example:

package main

import "fmt"

func main() {
    var num int = 10
    var ptr *int

    ptr = &num

    fmt.Println("num 的值是：", num)
    fmt.Println("ptr 的值是：", ptr)
    fmt.Println("ptr 指向的值是：", *ptr)
}

In the above code, We declared an integer variable num and an integer pointer variable ptr, and then obtained the address of the num variable through the & operator Assign value to pointer variable ptr. Finally, access the variable pointed to by the pointer through *ptr.

Pointer as function parameter

In the Go language, passing a pointer as a parameter of a function can directly modify the original variable instead of modifying its copy. The sample code is as follows:

package main

import "fmt"

func changeValue(ptr *int) {
    *ptr = 20
}

func main() {
    var num int = 10
    fmt.Println("修改前的值是：", num)
    
    changeValue(&num)
    fmt.Println("修改后的值是：", num)
}

In the above code, we define a changeValue function, which accepts an integer pointer as a parameter and modifies the value of the original variable through the pointer. Calling the changeValue function in the main function can directly modify the value of the num variable.

Array of pointers and array of pointers

A pointer array is an array that stores pointer elements, and an array of pointers is a pointer that points to the first element of the array. The code example is as follows:

package main

import "fmt"

func main() {
    var num1, num2, num3 int = 1, 2, 3
    var ptrArray [3]*int

    ptrArray[0] = &num1
    ptrArray[1] = &num2
    ptrArray[2] = &num3

    fmt.Println("num1: ", *ptrArray[0])
    fmt.Println("num2: ", *ptrArray[1])
    fmt.Println("num3: ", *ptrArray[2])
}

In the above code, we define three integer variables and a pointer array ptrArray, and store the addresses of these three variables into the array. By traversing the pointer array, the value of each variable can be obtained.

Through the above code examples, we have a preliminary understanding of the basic concepts and usage of pointers in the Go language. Although pointers have some complicated concepts, they are very useful tools in actual programming and can improve the efficiency and performance of the program. I hope that through the introduction of this article, readers will have an understanding of pointers and be able to better use the concept of pointers for Go language programming.

The above is the detailed content of Learning Golang from scratch: exploring the secrets of pointers. For more information, please follow other related articles on the PHP Chinese website!