golang_09问题

1. 写⼀个程序，获取⼀个变量的地址，并打印到终端 课后练习 
2. 写⼀个函数，传⼊⼀个int类型的指针，并在函数中修改所指向的值

package main

import (
"fmt"
"math/rand"
"time"
)

func main() {
rand.Seed(time.Now().Unix())
fmt.Println(rand.Intn(100))
fmt.Println(rand.Intn(100))

————————————————
版权声明：本文为CSDN博主「aslackers」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/aslackers/article/details/78548738

几点注意项：

1、如果不使用rand.Seed(seed int64)，每次运行，得到的随机数会一样，程序不停止，一直获取的随机数是不一样的；

2、每次运行时rand.Seed(seed int64)，seed的值要不一样，这样生成的随机数才会和上次运行时生成的随机数不一样；

3、rand.Intn(n int)得到的随机数int i，0 <= i < n。


————————————————
版权声明：本文为CSDN博主「aslackers」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/aslackers/article/details/78548738

 

func testPoint7() {
    var a int = 10
    var b *int = &a
    var c *int = b
    *c = 100
    fmt.Printf("*c=%d *b=%d a=%d\n", *c, *b, a)

}

1.变量和内存地址
2. 指针类型
3. 值拷⻉和引⽤拷⻉
4. 课后练习

每个变量都有内存地址，可以说通过变量来操作对应⼤⼩的内存

注意：通过&符号可以获取变量的地址
func main() {
    var a int32
    a = 1000
    fmt.Printf("the addr of a :%p, a:%d", &a, a)
}

普通变量存储的是对应类型的值，这些类型就叫值类型

指针类型的变量存储的是⼀个地址，所以⼜叫指针类型或引⽤类型
4. 指针类型定义，var 变量名 *类型
  var a *int = &b

5. 指针类型变量的默认值为nil，也就是空地址
　　　　var b *int

注意：通过* 符号可以获取指针变量指向的变量
func testPoint5() {
    var a *int = new(int)
    *a = 100
    fmt.Printf("*a=%d\n", *a)

    var b *[]int = new([]int)
    fmt.Printf("*b= %v\n", *b)
    (*b) = make([]int, 5, 100)
    (*b)[0] = 100
    (*b)[1] = 200
    fmt.Printf("*b 的值是 %v", *b)
}

通过指针修改变量的值
func testPoint2() {
    var a int = 200000
    var b *int = &a
    fmt.Printf("b 指向的地址存储的值为；%p,%d\n", &b, b)
    *b = 1000
    fmt.Printf("b 指向的地址存储的值为；%d\n", b)
    fmt.Printf("a 的值为 %d\n", a)
}

指针变量传参

func modify(a *int) {
    *a = 100
}

func modify_arr(a *[3]int) {
    (*a)[0] = 100
}

func testPoint4() {
    var b [3]int = [3]int{1, 2, 3}
    modify_arr(&b)
    fmt.Printf("b 的值是%v\n", b)

}

package main

import "fmt"

func testPoint1() {
    var a int32
    a = 100
    fmt.Printf("the add or a :%p a:%d\n", &a, a)

    var b *int32 //这里为什么加*
    fmt.Printf("the add or a :%p b;%v\n", &b, b)
    if b == nil {
        fmt.Println("b  is nil addr")
    }

    b = &a //这里为什么;将a的内存地址赋值给b的内存地址
    fmt.Printf("the add of b is %p,b %v\n", &b, b)
}

func testPoint2() {
    var a int = 200000
    var b *int = &a
    fmt.Printf("b 指向的地址存储的值为；%p,%d\n", &b, b)
    *b = 1000
    fmt.Printf("b 指向的地址存储的值为；%d\n", b)
    fmt.Printf("a 的值为 %d\n", a)
}

func modify(a *int) {
    *a = 100
}

func testPoint3() {
    var b int = 10
    p := &b
    modify(p)
    fmt.Printf("b 的值是%d", b) //b的值被修改了，为什么呢因为是同一个内存地址
}

func modify_arr(a *[3]int) {
    (*a)[0] = 100
}

func testPoint4() {
    var b [3]int = [3]int{1, 2, 3}
    modify_arr(&b)
    fmt.Printf("b 的值是%v\n", b)

}

func testPoint5() {
    var a *int = new(int)
    *a = 100
    fmt.Printf("*a=%d\n", *a)

    var b *[]int = new([]int)
    fmt.Printf("*b= %v\n", *b)
    (*b) = make([]int, 5, 100)
    (*b)[0] = 100
    (*b)[1] = 200
    fmt.Printf("*b 的值是 %v", *b)
}

func modifyInt(a *int) { //传入内存地址，修改值
    *a = 1000
}

func testPoint6() {
    var b int = 10
    modifyInt(&b)
    fmt.Printf("b=%d\n", b)
}

func testPoint7() {
    var a int = 10
    var b *int = &a
    var c *int = b
    *c = 100
    fmt.Printf("*c=%d *b=%d a=%d\n", *c, *b, a)

}

func main() {

    // testPoint1()
    // testPoint2()
    // testPoint3()
    // testPoint4()
    testPoint5()
    // testPoint6()
    // testPoint7()
}