【从零开始学习Go语言】九.Go语言之变量常量及指针总结
【从零开始学习Go语言】九.Go语言之变量常量及指针总结
【从零开始学习Go语言】九.Go语言之变量和常量- 一.变量
- 1.1 显示的完整声明
- 1.2 简短声明
- 二.常量
- 三.基础类型
- 四. 指针
- 4.1定义
- 4.2 用途
- 1.1 显示的完整声明
- 1.2 简短声明
- 4.1定义
- 4.2 用途
- 五.总结
一.变量
变量是通过一个名称绑定一块内存地址，该内存地址所存储的数据类型由定义变量时指定，该内存的地址数据可以被改变；变量声明的方法有多种
1.1 显示的完整声明
package main
import "fmt"
func main() {
var a int = 123
fmt.Println(a)
}1.2 简短声明
package main
import "fmt"
func main() {
a := 123
fmt.Println(a)
}PS:go语言支持多个变量同时声明。例：
package main
import "fmt"
func main() {
a, b := 123, 321
fmt.Println(a, b)
}二.常量
常量支持的数据类型有：数值型，字符串，布尔型，浮点型，基本声明方式为：
package main
import (
"fmt"
)
func main() {
const name datatype = name //单个定义常量
const name datatype = name
const name datatype = name
const ( //多个一起声明
LENGTH string = "helloworld"
test int = 321
true1 bool = true
flast float64 = 12.321
)
fmt.Println(LENGTH, test, true1, flast)
}- iota标识符
package main
import (
"fmt"
)
func main() {
const (
c1 = iota + 1 //可以进行基础运算
c2
c3
c4
)
fmt.Println(c1, c2, c3, c4)
}三.基础类型
之前有介绍所有的类型分类，类型的不同存储的数据形态是不同的，英文不好的可能不记得代码中的表示是什么，可以像下面这样去查看。
布尔类型
package main
import (
"fmt"
)
func main() {
a := true
fmt.Printf("this is: %T \n",a)
b := 123
fmt.Printf("this is: %T \n",b)
c := 1.1
fmt.Printf("this is: %T \n",c)
d := "hello world"
fmt.Printf("this is: %T \n",d)
e := 3+6i
fmt.Printf("this is: %T \n",e)
····
}返回：
this is: bool
this is: int
this is: float64
this is: string
this is: complex128 //这里演示一部分吧，太多了懒得打。。。四. 指针
4.1定义
所谓指针其实你可以把它想像成一个箭头，这个箭头指向（存储）一个变量的地址
因为这个箭头本身也需要变量来存储，所以也叫做指针变量。
Go的指针不支持那些乱七八糟的指针移位。它就表示一个变量的地址。看看这个例子：
package main
import (
"fmt"
)
func main() {
var x int
var x_ptr *int
x = 10
x_ptr = &x
fmt.Println(x)
fmt.Println(x_ptr)
fmt.Println(*x_ptr)
}上面例子输出x的值，x的地址和通过指针变量输出x的值，而x_ptr就是一个指针变量。
10
0xc084000038
10认真理清楚这两个符号的意思。
& 取一个变量的地址
*取一个指针变量所指向的地址的值
考你一下，上面的例子中，如何输出x_ptr的地址呢？
package main
import (
"fmt"
)
func main() {
var x int
var x_ptr *int
x = 10
x_ptr = &x
fmt.Println(&x_ptr)
}此例看懂，指针就懂了。
永远记住一句话，所谓指针就是一个指向（存储）特定变量地址的变量。没有其他的特别之处。我们再变态一下，看看这个：
package main
import (
"fmt"
)
func main() {
var x int
var x_ptr *int
x = 10
x_ptr = &x
fmt.Println(*&x_ptr)
}- x_ptr 是一个
指针变量，它指向(存储)x的地址； - &x_ptr 是
取这个指针变量x_ptr的地址，这里可以设想有另一个指针变量x_ptr_ptr(指向)存储这个x_ptr指针的地址； - *&x_ptr 等价于
*x_ptr_ptr就是取这个x_ptr_ptr指针变量所指向(存储)的地址所对应的变量的值，也就是x_ptr的值，也就是指针变量x_ptr指向(存储)的地址，也就是x的地址。 这里可以看到，其实*&这两个运算符在一起就相互抵消作用了。
4.2 用途
指针的一大用途就是可以将变量的指针作为实参传递给函数，从而在函数内部能够直接修改实参所指向的变量值。` Go的变量传递都是值传递。
package main
import (
"fmt"
)
func change(x int) {
x = 200
}
func main() {
var x int = 100
fmt.Println(x)
change(x)
fmt.Println(x)
}上面的例子输出结果为
100
100很显然，change函数改变的仅仅是内部变量x的值，而不会改变传递进去的实参。其实，也就是说Go的函数一般关心的是输出结果，而输入参数就相当于信使跑到函数门口大叫，你们这个参数是什么值，那个是什么值，然后就跑了。你函数根本就不能修改它的值。不过如果是传递的实参是指针变量，那么函数一看，小子这次你地址我都知道了，哪里跑。那么就是下面的例子：
package main
import (
"fmt"
)
func change(x *int) {
*x = 200
}
func main() {
var x int = 100
fmt.Println(x)
change(&x)
fmt.Println(x)
}上面的例子中，change函数的虚参为整型指针变量，所以在main中调用的时候传递的是x的地址。然后在change里面使用*x=200修改了这个x的地址的值。所以x的值就变了。这个输出是：
100
200new
new这个函数挺神奇，因为它的用处太多了。这里还可以通过new来初始化一个指针。上面说过指针指向(存储)的是一个变量的地址，但是指针本身也需要地址存储。先看个例子：
package main
import (
"fmt"
)
func set_value(x_ptr *int) {
*x_ptr = 100
}
func main() {
x_ptr := new(int)
set_value(x_ptr)
//x_ptr指向的地址
fmt.Println(x_ptr)
//x_ptr本身的地址
fmt.Println(&x_ptr)
//x_ptr指向的地址值
fmt.Println(*x_ptr)
}上面我们定义了一个x_ptr变量，然后用new申请了一个存储整型数据的内存地址，然后将这个地址赋值给x_ptr指针变量，也就是说x_ptr指向（存储）的是一个可以存储整型数据的地址，然后用set_value函数将这个地址中存储的值赋值为100。所以第一个输出是x_ptr指向的地址，第二个则是x_ptr本身的地址，而*x_ptr则是x_ptr指向的地址中存储的整型数据的值。
0xc084000040
0xc084000038
100五.总结
好了，现在用个例子再来回顾一下指针。 交换两个变量的值。
package main
import (
"fmt"
)
func swap(x, y *int) {
*x, *y = *y, *x
}
func main() {
x_val := 100
y_val := 200
swap(&x_val, &y_val)
fmt.Println(x_val)
fmt.Println(y_val)
}这里利用了Go提供的交叉赋值的功能，另外由于是使用了指针作为参数，所以在swap函数内，x_val和y_val的值就被交换了。