深入理解Golang中指针的用途与技巧

 var p *int  // 声明一个指向 int 类型的指针 p
 var str *string  // 声明一个指向 string 类型的指针 str

 p := new(int)  // 分配一个 int 类型的内存，并将指针 p 指向该内存

 package main
 ​
 import "fmt"
 ​
 func main() {
     var p *int
     var str *string
 ​
     fmt.Printf("p: %v, str: %v\n", p, str) // 输出 p: <nil>, str: <nil>
 ​
     x := 10
     p = &x // 将指针p指向变量x的地址
 ​
     fmt.Printf("p: %v\n", p)   // 输出 p: 0xc0000100e0
     fmt.Printf("*p: %d\n", *p) // 输出 *p: 10
 ​
     str = new(string) // 分配一个string类型的内存，并将指针str指向该内存
 ​
     fmt.Printf("str: %v\n", str)   // 输出 str: 0xc000010120
     fmt.Printf("*str: %s\n", *str) // 输出 *str: ""
 ​
     *str = "Hello, Go!" // 通过指针修改字符串的值
 ​
     fmt.Printf("*str: %s\n", *str) // 输出 *str: Hello, Go!
 }

x := 10
 p := &x  // 将指针 p 指向变量 x 的地址
 ​
 a := 10
 b := &a // 将指针 b 指向变量 a 的地址

 fmt.Println(*p)  // 输出指针 p 指向的值，即变量 x 的值

func main() {
     //指针取值
     a := 10
     b := &a // 取变量a的地址，将指针保存到b中
     fmt.Printf("type of b:%T\n", b)
     c := *b // 指针取值（根据指针去内存取值）
     fmt.Printf("type of c:%T\n", c)
     fmt.Printf("value of c:%v\n", c)
 }

 package main
 ​
 import "fmt"
 ​
 func changeValue(ptr *int) {
     *ptr = 20 // 修改指针指向的值
 }
 ​
 func main() {
     x := 10
     changeValue(&x) // 传递x的地址给changeValue函数
     fmt.Println(x) // 输出修改后的x的值，即20
 }

package main
 ​
 import "fmt"
 ​
 type BigObject struct {
     // 大对象的定义...
 }
 ​
 func processObject(obj *BigObject) {
     // 对大对象进行处理...
 }
 ​
 func main() {
     obj := BigObject{}
     processObject(&obj) // 传递大对象的指针
 }

package main
 ​
 import "fmt"
 ​
 func modifyValue(ptr *int) {
     *ptr = 30 // 修改指针指向的值
 }
 ​
 func main() {
     x := 10
     modifyValue(&x) // 传递x的地址给modifyValue函数
     fmt.Println(x) // 输出修改后的x的值，即30
 }

 package main
 ​
 import "fmt"
 ​
 type ComplexStruct struct {
     // 复杂数据结构的定义...
 }
 ​
 func createComplexStruct() *ComplexStruct {
     cs := new(ComplexStruct) // 动态分配内存并返回指针
     // 初始化复杂数据结构...
     return cs
 }
 ​
 func main() {
     obj := createComplexStruct()
     // 对动态分配的数据结构进行操作...
 }

package main
 ​
 import "fmt"
 ​
 func createValue() *int {
     x := 10 // 在函数内部创建变量
     return &x // 返回变量的地址
 }
 ​
 func main() {
     p := createValue()
     fmt.Println(*p) // 输出通过指针访问的函数内部变量的值，即10
 }

func main() {
     var a *int
     *a = 100
     fmt.Println(*a)
 ​
     var b map[string]int
     b["沙河娜扎"] = 100
     fmt.Println(b)
 }

func new(Type) *Type

 func main() {
     a := new(int)
     b := new(bool)
     fmt.Printf("%T\n", a) // *int
     fmt.Printf("%T\n", b) // *bool
     fmt.Println(*a)       // 0
     fmt.Println(*b)       // false
 }

func make(t Type, size ...IntegerType) Type

 func main() {
     var b map[string]int
     b = make(map[string]int, 10)
     b["沙河娜扎"] = 100
     fmt.Println(b)
 }