Golang-基础数据类型二

强制类型数据转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换的基本格式如下：

type_name(expression)

在做强制类型转换时，需要特别注意数据长度被截断而发生的 数据精度损失（比如将浮点型转换为整型）与 值溢出（值超过转换目标类型的值范围时）。

func main() {
    num := 5
    num1 := 11
    num2 := float32(num) // 把整型转换成浮点型
    num3 := float32(num1)
    mean := num1 / num   // 原来的运算
    mean1 := num3 / num2 // 转换后的运算

    fmt.Println("没有经过类型转换的值：", mean)
    fmt.Println("经过类型转换的值：", mean1)
}
/*
没有经过类型转换的值：2
经过类型转换的值：2.2
*/

类型别名

类型别名是 Go 1.9 版本添加的新功能，主要用于解决代码升级、迁移中存在的类型兼容性问题（重构中常用）。

在前面数据类型的学习中，我们已经知道了 byte 类型是 int8 类型的别名，rune 类型是 int32 的别名。Go 语言允许开发者自定义类型别名。

type (
    //Go 1.9 版本加入了类型别名的新特性
    完满主任 string
)
func main() {
    var b 完满主任 // 自定义类型别名
    b = "高举完满教育的伟大旗帜,"
    fmt.Println(b)
    a := "坚持一百年完满教育不动摇"
    // fmt.Println(b + a) // 编译报错，规定类型别名与原类型是两种不同的类型，但本质是一样的
    fmt.Println(string(b) + a) // 强制类型转换
}
/*
高举完满教育的伟大旗帜,
高举完满教育的伟大旗帜, 坚持一百年完满教育不动摇
*/

指针

所有指针变量都是一个内存位置，每个内存位置都有其定义的地址，可以使用 & 运算符号，这个运算符表示内存中的地址。

使用指针基本上是三个步骤：

• 定义一个指针变量
• 将某个变量的值赋值给一个指针
• 最后访问指针变量中可用地址的值

指针数组

const MAX int = 3 // 数组大小

func main() {

    var a *int               // 定义空指针 a，指向 nil
    aP := &a                 // 定义空指针 a 的指针 aP
    b := []int{10, 100, 200} // 数组存储三个指向 int 型的值
    var ptr [MAX] *int        // 声明 ptr 为指针数组，数组长度是 MAX

    for i := 0; i < MAX; i++ {ptr[i] = &b[i]
        fmt.Printf("a[d]的地址：%x\n", i, ptr[i])
    }

    for i := 0; i < MAX; i++ {fmt.Printf("a[%d]的值是：%x\n", i, *ptr[i])
    }

    fmt.Printf("a-->nil: %x\n", a)       // 打印空指针 a 的值，指向 nil，为 0
    fmt.Printf("aP-->a: %x\n", aP)       // 打印指针 aP 的值，指向 a
    fmt.Printf("aP-->a--nil: %x\n", *aP) // 打印指针 aP 指向的指针 a 的内存地址
    fmt.Printf("&aP-->aP: %x\n", &aP)    // 打印 aP 在内存的地址
}

/*
a[d]的地址：0
%!(EXTRA *int=0xc0000123a0)a[d]的地址：1
%!(EXTRA *int=0xc0000123a8)a[d]的地址：2
%!(EXTRA *int=0xc0000123b0)a[0]的值是：a
a[1]的值是：64
a[2]的值是：c8
a-->nil: 0
aP-->a: c000006028
aP-->a--nil: 0
&aP-->aP: c000006030
*/
}

传递给函数

Go 语言允许传递指针到 函数 中，只需将函数的参数声明为 指针类型。

func main() {
    a := 100
    b := 200

    fmt.Printf("交换前 a 的值：%d\n", a)
    fmt.Printf("交换前 b 的值：%d\n", b)

    // 把 a 和 b 的地址传递给函数，然后 a 和 b 的地址交换，实现两个值的交换
    swap(&a, &b)

    fmt.Printf("交换后 a 的值：%d\n", a)
    fmt.Printf("交换后 b 的值：%d\n", b)

}

func swap(x *int, y *int) { // 构造一个 swap 函数

    var temp int
    temp = *x // 存指针 x 的地址，自动推导指针类型
    *x = *y   // 存指针 y 的地址
    *y = temp // 交换地址
}
/*
交换前 a 的值：100
交换前 b 的值：200
交换后 a 的值：200
交换后 b 的值：100
*/