Home >Backend Development >Golang >What is a Go Pointer? What are the knowledge points that need to be mastered?
This article is provided by the go language tutorial column to introduce you to 11 knowledge points about What is a Go Pointer? What are the knowledge points that need to be mastered? Pointer pointers. I hope it will be helpful to friends in need!
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 What is a Go Pointer? What are the knowledge points that need to be mastered?.
A pointer is a variable that stores the address it points to. Pointers of a specific type can only point to that type (data types are immutable).
The syntax of pointers is very simple. Following is the syntax for pointer declaration in What is a Go Pointer? What are the knowledge points that need to be mastered?.
var ptr *typevar ptrint *int // 指向 int 的指针
The zero value of a pointer is nil.
type pointers are initialized using &:
package mainimport (
"fmt")func main() {
var q int = 42
var p *int // declare the pointer
p = &q // initialize the pointer
fmt.Println(p) // 0x40e020}
Pointer value means getting the value in the address saved by the pointer. The following is an example of using the * operator to perform a pointer value operation:
package mainimport (
"fmt")func main() {
var q int = 42
var p *int
p = &q
fmt.Println(p) // 0x40e020
fmt.Println(*p) // 42}
The address of the pointer is A numeric value that 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 mainimport (
"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)}
A pointer can point to anything, even to an interface. When using the empty interface, the returned value is nil.
package mainimport (
"fmt")func main() {
var a interface{}
b := &a
fmt.Println(b) // 0x40c138
fmt.Println(*b) // <nil>}</nil>
The following is an example of using an interface with pointers.
package mainimport (
"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. What is a Go Pointer? What are the knowledge points that need to be mastered? allows for polymorphism using interfaces. So you can see that pointers to structures or interfaces are an essential tool in What is a Go Pointer? What are the knowledge points that need to be mastered?.
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 mainimport (
"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, this is an example of passing a pointer to a structure. This is an efficient way to handle large objects.
package mainimport (
"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 that value pointer as a function parameter, and then make necessary modifications.
The new function in What is a Go Pointer? What are the knowledge points that need to be mastered? returns a pointer to a type.
package mainimport (
"fmt")func main() {
ptri := new(int)
*ptri = 67
fmt.Println(ptri) // 0x40e020
fmt.Println(*ptri) // 67}
Any type of pointer can be returned from a function like other values. It's really simple. We don't return the value directly, but the address of the value.
package mainimport (
"fmt")func p() *int { // 将返回类型指定为指针
v := 101
// 返回地址
return &v}func main() {
n := p()
fmt.Println(n) // 0x40e020
fmt.Println(*n) // 101}
Pointers to functions work implicitly in What is a Go Pointer? What are the knowledge points that need to be mastered?. This means we don't need to declare it as a pointer.
package mainimport (
"fmt")func main() {
f := func() {
fmt.Println("a function")
}
pf := f pf() // 一个函数}
Pointer arithmetic is not allowed in What is a Go Pointer? What are the knowledge points that need to be mastered?. 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.
Original address: https://golangdocs.com/pointers-in-golang
Translation address: https://learnku.com/go/t/60880
The above is the detailed content of What is a Go Pointer? What are the knowledge points that need to be mastered?. For more information, please follow other related articles on the PHP Chinese website!