GO学习笔记——GO语言常量与枚举（6）
看完了变量的定义，再来看常量。
GO语言中常量定义使用关键字const，这个关键字倒是和C++相像。
常量的定义方法和变量定义差不多，这里就一笔带过了。
1. 定义一个简单常量，同样可以把它定义成局部变量或者是全局变量
const a int = 5
func main() {
const b int = 5
fmt.Println(a,b)
}2.分组定义常量
const (
a int = 5
b int = 5
)
func main() {
fmt.Println(a,b)
}3.一行定义多个常量
func main() {
const a,b int = 5,5
fmt.Println(a,b)
}4.省略类型的常量定义
func main() {
const a,b = 5,5
fmt.Println(a,b)
fmt.Println(reflect.TypeOf(a),reflect.TypeOf(b))
}
//输出结果
5 5
int int可以看到常量的定义和变量是差不多的，只不过有几个地方需要注意
- 常量定义的时候一定要加上const关键字。之前说变量定义的时候，如果是局部变量我们可以省略var关键字，但是如果在函数体内定义常量，不能省略const关键字，很简单，我们省略了const，那不就和变量一样了吗？所以一句话，常量定义一定要加上const关键字
- 常量定义的同时必须赋值，也就是说我们不能够在常量的定义的时候不可以像变量那样不赋值，只声明，从而使用默认零值。常量定义的时候必须同时赋值
- 因为必须使用const关键字，所以常量也没有想变量定义那样的简化方法，即使用冒号 ':' 定义，因为使用冒号 ':' 定义，是因为我们省略了var关键字，这边必须使用const关键字，所以也没有这种定义的方法。
func main() {
a,b := 5,5
fmt.Println(a,b)
}
//上面这就是变量的定义了，不是常量
func main() {
const a int
fmt.Println(a)
}
//错误提示
.\main.go:9:10: missing value in const declaration
func main() {
const a,b := 5,5
fmt.Println(a,b)
}
//错误提示
.\main.go:9:8: missing value in const declaration
.\main.go:9:12: syntax error: unexpected := at end of statement另外，还有一个点需要注意，这个是编译器方面的推断类型导致的，看如下代码
func main() {
a,b := 3,4
var c int
c = int (math.Sqrt(a*a + b*b))
fmt.Println(c)
}程序会报错，因为sqrt函数的参数浮点类型，而这里a和b是变量，编译器将a和b推断成了int类型，要变成浮点类型必须强转
.\main.go:12:25: cannot use a * a + b * b (type int) as type float64 in argument to math.Sqrt但是如果a和b是常量，就可以了
func main() {
const a,b = 3,4
var c int
c = int (math.Sqrt(a*a + b*b))
fmt.Println(c)
}
//输出结果
5这是因为，常量其实本质上做的是一个文本替换，这里的a和b它既可以是int，也可以是浮点型，编译器不管这个，编译器只将a和b出现的地方用3和4代替了，实际上，那句sqrt相当于下面的表达式
c = int (math.Sqrt(25))这是常量和变量在省略类型时的一点参数，只要注意常量的话它会是一个文本替换，可以作为任意类型使用，而变量是推断出具体类型。
5.使用内置表达式来定义厂常量
还可以使用一些内置表达式来定义常量，如：len（）,unsafe.Sizeof（）等
const name = "pigff"
const length = len(name)
const size = unsafe.Sizeof(name) //用于求变量大小
func main() {
fmt.Println(name,length,size)
}输出结果
pigff 5 16注意看，这里为什么Sizeof一个字符串的大小会是16？原因是GO中的sring内部实现由两部分组成，一部分是指向字符串起始地址的指针，另一部分是字符串的长度，两部分各是8字节，所以一共16字节。这部分具体会在后面的文章说到，这里提一下。
和C++做个对比，len其实相当于C++中string类的length接口，而C++中对于字符串求sizeof的大小是根据编译器决定的，不同平台下求出的结果也不一样，vs2017下求出来时28，而Linux下用g++求出来就是8，具体要看平台，编译器，以及编译器版本。
自己实现的函数，不可以这样用来赋值给常量
func fun(name string) string{
return name
}
const name = fun("pigff")
func main() {
fmt.Println(name)
}程序会报错
.\main.go:11:7: const initializer fun("pigff") is not a constant所以只有内置的表达式和函数才可以这么定义。
使用常量定义枚举类型
GO语言中有一个特殊常量——枚举类型，C++中有enum关键字来定义枚举类型，而GO语言中则没有这样的关键字，GO中使用一组const常量来表示枚举类型。
我们知道，枚举类型的数值是从0开始的，为了对比，我们先来看一下一段C++代码。
#include
using namespace std;
enum{
EAST,
SOUTH,
WEST,
NORTH
};
int main(){
int a[] = {EAST,SOUTH,WEST,NORTH};
for(int i = 0; i < 4; ++i)
cout << a[i] << " ";
cout << endl;
return 0;
}
我们在main函数中对这几个枚举值一一输出它们的值，结果如下
0 1 2 3可以看到确实是从0开始的，那么这样的枚举类型在GO语言中是如何实现的呢？
GO使用一组const来表示枚举类型，并使用了iota这个常量计数器
先试着像C++那样定义枚举类型
const (
EAST
SOUTH
WEST
NORTH
)
func main() {
fmt.Println(EAST,SOUTH,WEST,NORTH)
}诚然，因为这些常量没有定义，编译器会报错
.\main.go:6:2: missing value in const declaration那么我们就可以给它们来手动定义
const (
EAST = 0
SOUTH = 1
WEST = 2
NORTH = 3
)
func main() {
fmt.Println(EAST,SOUTH,WEST,NORTH)
}输出的结果就是预期的
0 1 2 3那么如果这个我们想要表达的枚举类型很多怎么办？我们都手动定义吗，不能像C++那样从0开始自动增长吗？
为了解决这个问题，引入了常量计数器iota，来看下GO语言是怎么做到自动增长的
const (
EAST = iota
SOUTH
WEST
NORTH
)
func main() {
fmt.Println(EAST,SOUTH,WEST,NORTH)
}输出结果和上面一样
0 1 2 3好了，下面来具体了解一下这个iota到底是个啥
常量计数器iota
iota是GO语言的常量计数器，只可以在常量表达式中使用（给常量赋值）
- iota在const关键字出现时将被重置为0
- const中每新增一行常量声明将使iota计数+1（注意在同一行计数不+1）
上面就是使用iota这个常量计数器的关键。
1. iota只可以给常量比表达式使用，其余地方不可使用
func main() {
fmt.Println(iota)
}程序会报错，以为iota是一个变量名
.\main.go:13:14: undefined: iota2.const中每新增一行常量声明将使iota计数+1（这一般出现在分组定义常量的时候）
func main() {
const (
a = iota //iota为0，a为0
b //新增了一行常量定义，iota++，b为1
c //新增了一行常量定义，iota++，c为2
)
fmt.Println(a,b,c)
}输出结果如下
0 1 23.出现关键字const时，iota就会被重置为0（可能一个程序要声明多个枚举类型，就需要这个条件）
func main() {
const (
a = iota
b
c
)
const (
d = iota
e
f
)
fmt.Println(a,b,c)
fmt.Println(d,e,f)
}输出结果如下
0 1 2
0 1 2iota有多种使用方法，一起来看一下
1. 跳值使用法
func main() {
const (
a = iota //a是0
b //b是1
_ //2被跳过了
c //c是3
)
fmt.Println(a,b,c)
}输出结果
0 1 32. 插队使用法
在a和c之间插入一个不是iota赋值的常量b，这个时候iota还是会+1
func main() {
const (
a = iota //a是0
b = 3 //b是3，iota仍旧++
c = iota //c是2,不是0，此时iota是2
)
fmt.Println(a,b,c)
}输出结果
0 3 23. 表达式隐式使用法
如果后面的常量没有赋值，那么会向上找第一个不为空的赋值表达式
func main() {
const (
a = iota * 2 //a是0，iota++
b = iota //b是1，iota++
c = iota //c是2
)
fmt.Println(a,b,c)
}这个时候，把b和c的赋值都省略
func main() {
const (
a = iota * 2 //a是0，iota++
b //b是2，iota++
c //c是4
)
fmt.Println(a,b,c)
}输出结果如下
0 2 4验证一下，会向上使用第一个非空的赋值表达式
func main() {
const (
a = iota * 2 //a是0，iota++
b = iota * 3 //b是3，iota++
c //c是6,沿用了b的赋值表达式，而不是a的
d //d是9,沿用了b的赋值表达式，而不是a的
)
fmt.Println(a,b,c,d)
}输出结果如下
0 3 6 9 因此，通过这种方法，可以有多元化的常量赋值，不一定是自增长的，也可以是二倍自增的，这也是GO语言枚举类型的一个巧妙之处
4.单行使用法
格式一致，沿用之前对应的赋值格式
func main() {
const (
a,b = iota,iota + 2 //a为0，b为2，iota++
c,d //等价于c = iota，d = iota + 2，所以c为1，b为3
)
fmt.Println(a,b,c,d)
}输出结果
0 2 1 3注意格式必须一致，格式不一致就会导致出错的问题（即第一行是两个变量，后面的也必须是两个变量）
func main() {
const (
a,b = iota,iota + 2
c,d
e //格式不一致
)
fmt.Println(a,b,c,d)
}上面程序格式不一致会出错
.\main.go:16:3: extra expression in const declaration