var p *int  // 聲明一個指向 int 類型的指針 p
 var str *string  // 聲明一個指向 string 類型的指針 str

 p := new(int)  // 分配一個 int 類型的內(nèi)存，并將指針 p 指向該內(nèi)存

 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類型的內(nèi)存，并將指針str指向該內(nèi)存
 ?
     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 // 指針取值（根據(jù)指針去內(nèi)存取值）
     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函數(shù)
     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函數(shù)
     fmt.Println(x) // 輸出修改后的x的值，即30
 }

 package main
 ?
 import "fmt"
 ?
 type ComplexStruct struct {
     // 復(fù)雜數(shù)據(jù)結(jié)構(gòu)的定義...
 }
 ?
 func createComplexStruct() *ComplexStruct {
     cs := new(ComplexStruct) // 動態(tài)分配內(nèi)存并返回指針
     // 初始化復(fù)雜數(shù)據(jù)結(jié)構(gòu)...
     return cs
 }
 ?
 func main() {
     obj := createComplexStruct()
     // 對動態(tài)分配的數(shù)據(jù)結(jié)構(gòu)進行操作...
 }

package main
 ?
 import "fmt"
 ?
 func createValue() *int {
     x := 10 // 在函數(shù)內(nèi)部創(chuàng)建變量
     return &x // 返回變量的地址
 }
 ?
 func main() {
     p := createValue()
     fmt.Println(*p) // 輸出通過指針訪問的函數(shù)內(nèi)部變量的值，即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)
 }