【从零开始学习Go语言】九.Go语言之变量常量及指针总结

一.变量

变量是通过一个名称绑定一块内存地址，该内存地址所存储的数据类型由定义变量时指定，该内存的地址数据可以被改变；变量声明的方法有多种

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定义

指针其实你可以把它想像成一个箭头，这个箭头指向（存储）一个变量的地址

不支持那些乱七八糟的指针移位它就表示一个变量的地址

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的地址取这个指针变量x_ptr的地址有另一个指针变量x_ptr_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

改变的内部变量x值不会改变实参

package main
import (
	"fmt"
)
func change(x *int) {
	*x = 200
}
func main() {
	var x int = 100
	fmt.Println(x)
	change(&x)
	fmt.Println(x)
}

整型指针变量传递的是x的地址*x=200x的值就变了

100
200

初始化一个指针

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)
}

new申请存储整型数据的内存地址地址赋值x_ptr指针变量x_ptr指向（存储）的是一个可以存储整型数据的地址这个地址中存储的值x_ptr指向的地址x_ptr本身的地址*x_ptrx_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)
}

交叉赋值