Go从入门到放弃之指针

1

2

3

4

v:代表被取地址的变量，类型为T

ptr:用于接收地址的变量，ptr的类型就为*T，称做T的指针类型。*代表指针。

ptr := &v    // v的类型为　

1

2

3

4

5

6

7

func main() {

    a := 10

    b := &a

    fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078

    fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int

    fmt.Println(&b)                    // 0xc00000e018

}

1

2

3

4

5

6

7

8

9

10

11

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)

}输出如下：type of b:*int

type of c:int

value of c:10

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

func modify1(x int) {

    x = 100

}

func modify2(x *int) {

    *x = 100

}

func main() {

    a := 10

    modify1(a)

    fmt.Println(a) // 10

    modify2(&a)

    fmt.Println(a) // 100

}

1

2

Type表示类型，new函数只接受一个参数，这个参数是一个类型

*Type表示类型指针，new函数返回一个指向该类型内存地址的指针。func new(Type) *Type

1

2

3

4

5

6

7

8

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

}  

1

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

1

2

3

4

5

6

func main() {

    var b map[string]int

    b = make(map[string]int, 10)

    b["沙河娜扎"] = 100

    fmt.Println(b)

}

1

2

3

二者都是用来做内存分配的。

make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身；

而new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。