Go语言的数据类型
C语言的数据类型
Go语言的数据类型
Go语言各数据类型占用内存空间
- Go语言中也可以使用sizeof()
- 如何使用sizeof(): 导入unsafe包, 利用unsafe.Sizeof调用函数
重点: Go语言中的int类型会根据系统自动调整,如果系统是64位,那么int就会自动变成int64,如果是32位那么int会自动变成int32,所以企业开发中一般使用int
- 如何使用sizeof(): 导入unsafe包, 利用unsafe.Sizeof调用函数
package main
import (
"fmt"
"unsafe"
)
func main() {
// 有符号整型,int数字代表的是位数
fmt.Println("int size = ", unsafe.Sizeof(int(0))) //8
fmt.Println("int8 size =", unsafe.Sizeof(int8(0))) //1
fmt.Println("int16 size = ", unsafe.Sizeof(int16(0))) //2
fmt.Println("int32 size = ", unsafe.Sizeof(int32(0))) //4
fmt.Println("int64 size = ", unsafe.Sizeof(int64(0))) //8
//无符号整型
fmt.Println("uint size = ", unsafe.Sizeof(uint(0)))//8
fmt.Println("uint8 size = ", unsafe.Sizeof(uint8(0)))//1
fmt.Println("uint16 size = ", unsafe.Sizeof(uint16(0)))//2
fmt.Println("uint32 size = ", unsafe.Sizeof(uint32(0)))//4
fmt.Println("uint64 size = ", unsafe.Sizeof(uint64(0)))//8
fmt.Println("uintptr size = ", unsafe.Sizeof(uintptr(0)))//8
//字符类型
//byte相当于C语言中的char,专门用于保存一个字符'a'
//rune本质是int32,专门用于保存一个中文字符 '王'
//Go语言编写的代码默认UTF-8,Go语言默认支持中文,在UTF-8中一个中文占3个字节,所以无论什么平台Go中的中文都占用三个字节
fmt.Println("byte size = ", unsafe.Sizeof(byte(0)))//1
fmt.Println("rune size = ", unsafe.Sizeof(rune(0)))//4
//浮点类型
fmt.Println("float32 size = ", unsafe.Sizeof(float32(0))) //4
fmt.Println("float64 size = ", unsafe.Sizeof(float64(0))) //8
//布尔类型
fmt.Println("true size = ", unsafe.Sizeof(true)) //1
fmt.Println("false size = ", unsafe.Sizeof(false)) //1
}
Go语言数据类型的本质
- Go语言就是根据C语言来编写的,所以内部实现使用了C语言的很多代码
// 第8行到35行
typedef signed char int8;
typedef unsigned char uint8;
typedef signed short int16;
typedef unsigned short uint16;
typedef signed int int32;
typedef unsigned int uint32;
typedef signed long long int int64;
typedef unsigned long long int uint64;
typedef float float32;
typedef double float64;
#ifdef _64BIT
typedef uint64 uintptr;
typedef int64 intptr;
typedef int64 intgo; // Go's int
typedef uint64 uintgo; // Go's uint
#else
typedef uint32 uintptr;
typedef int32 intptr;
typedef int32 intgo; // Go's int
typedef uint32 uintgo; // Go's uint
#endif
#ifdef _64BITREG
typedef uint64 uintreg;
#else
typedef uint32 uintreg;
#endif
// 第153行到157行
enum
{
true = 1,
false = 0,
};
Go语言变量
Go语言中的变量和C语言一样
1. 什么是变量?
在C语言和Go语言中可以改变的数据,称之为变量
2. 为什么要定义变量
告诉操作系统我们要开辟多大的内存来存储数据
3.如何定义变量
在C语言中格式 数据类型 变量名称
在Go语言中格式 var 变量名称 数据类型
4.如何使用变量
在C语言中,变量名称在等号左边意味着往变量中存储数据,在等号的右边意味着从变量中获取数据
Go语言变量的使用和C语言一样
5.变量的初始化
在C语言中第一次给变量赋值叫做初始化，初始化有两种方式
第一种先定义变量再初始化，第二种是定义变量的同时初始化
Go语言变量初始化和C一样
Go语言中定义单个变量
注意点:
在Go语言中, 除了有和C语言一样的定义变量的格式以外, 还有一些其它的格式
1.如果定义的同时初始化, 那么定义变量时, 数据类型可以省略(系统会自动根据赋值推倒变量的类型)
2.如果定义的同时初始化, 那么定义变量时, 除了可以省略数据类型以外, 还可以利用:=继续省略var
使用 :=注意点:
1.如果利用:=定义变量, 那么不能写var也不能写数据类型
2.因为:=会先定义一个变量, 所以不能把:=当做=来使用
package main
import "fmt"
func main() {
// 1. 先定义变量再初始化
var num1 int
num1 = 6
fmt.Println(num1)
// 2. 定义的同时初始化
var num2 int = 7
fmt.Println(num2)
//3. 定义的同时初始化可以省略数据类型
var num3 = 3.12
fmt.Println(num3)
//在Go语言中可以通过%T来输出变量的数据类型
fmt.Printf("%T\n", num3)
//4. 定义的同时初始化使用 := 形式可以省略var关键字和数据类型
// := 做了两件事情,第一是定义一个变量,第二个是给这个变量赋值(经常使用)
num4 := 7.1
fmt.Println(num4)
}
Go语言中定义多个变量
1. 变量的连续定义
在C语言中我们可以通过逗号来连续定义多个变量 int a,b,c;
在Go语言中也可以使用逗号连续定义变量 var a,b,c int
而且Go中还可以使用变量组的形式定义多个变量
var (
a int
b int
c int
)
2.同时定义多个变量, 也可以在定义的时候初始化
在C语言中,int a = 10, b = 20, c = 30;
在Go语言中可以使用 var a,b,c int = 10, 20, 30
并且Go中还可以使用变量组定义多个变量并初始化
var(
a int = 10
b int = 20
c int = 30
注意点:在变量组中, 不能使用:=
)
package main
import "fmt"
func main() {
//先定义,后初始化
var a, b, c int
a = 11
b = 22
c = 33
fmt.Println(a, b, c)
//先定义变量组的形式,在初始化
var (
a int
b int
c int
)
a = 10
b = 20
c = 30
fmt.Println(a, b, c)
//同时定义多个变量且同时初始化
var a, b, c float64 = 2.1, 3.4, 3.8
fmt.Println(a, b, c)
var a, b, c = 10, 20, 30
fmt.Println(a, b, c)
//企业开发中经常使用这种方法
a, b, c := 10, 20, 30
fmt.Println(a, b, c)
//使用变量组定义的同时初始化
var (
a int = 10
b int = 20
c int = 30
)
fmt.Println(a, b, c)
//使用变量组定义的同时初始化,可以省略数据类型
var(
a = 10
b = 4
c = 6
)
fmt.Println(a, b, c)
//使用常量组定义多个变量
var(
a, b = 10, 20
c, d = 30, 40
)
fmt.Printf("%d, %d\n", a, b)
fmt.Printf("%d, %d\n", c, d)
}
全局变量和局部变量
- Go语言全局变量和局部变量基本差不多,但是也有一些不同点
1. 什么是局部变量
在C语言中局部变量就是在{}中,函数中或者函数的形参,都是局部变量
Go语言的局部变量和C语言一样
2. 什么是全局变量
C语言中写在函数的外面就是全局变量,Go语言的局部变量和C语言一样
3.局部变量和全局变量的作用域
C语言中局部变量作用域是从定义的那行开始,直到遇到}或者return结束,Go语言和C一样
C语言中全局变量从定义的那行开始,直到文件末尾
Go语言中全局变量只要定义了,在定义之前和定义之后都可以使用
4.局部变量和全局变量的生命周期
在C语言中局部变量, 只有执行了才会分配存储空间, 只要离开作用域就会自动释放, C语言的局部变量存储在栈区
Go语言的局部变量生命周期和C语言一样
在C语言中全局变量,只要是程序启动就会给其分配存储空间,程序结束后才会释放存储空间,全局变量存储在静态区(数据区)
Go语言的全局变量生命周期和C语言一样
5.局部变量和全局变量的注意点
在C语言中作用域相同不能出现相同名称的局部变量
Go语言和C语言一样, 相同的作用域内, 不能出现同名的局部变量
在C语言中相同的作用域内, 可以出现同名的全局变量
在Go语言中,在相同的作用域内,不能出现同名的全局变量
6.特殊点
在C语言中局部变量没有初始化存储的是垃圾数据
在C语言中全局变量没有初始化存储的是0, Go语言和C语言一样
在Go语言中, 如果定义了一个局部变量, 但是没有使用这个局部变量, 编译会报错
在Go语言中, 如果定义了一个全局变量, 但是没有使用这个全局变量, 编译不会报错
注意点总结:
在Go语言中,不管是全局变量还是局部变量,没有初始化默认存储的数据都是0
相同的作用域内, 无论是全局变量还是局部变量, 都不能出现同名的变量
局部变量不使用,编译器会报错
全局变量不使用,编译器不会报错
package main
func main() {
var num int; //不使用局部变量报错: num declared and not used
}
Go语言简短模式定义变量
使用 := 定义局部变量
- 简短模式定义变量是定义变量的同时初始化
- :=不能当做赋值运算符来使用
- 简短模式:= 只能定义局部变量,不能定义全局变量
package main
import "fmt"
//value := 333 编译器会报错
var value int = 333 //编译器不会报错
func main() {
}
- 使用简短模式定义变量,就不能再使用var关键字和数据类型
- :=不能使用在变量组中
- 通过:=同时定义多个变量, 必须给所有变量初始化
package main
import "fmt"
func main() {
//num1, num2 := 666, 888 // 正确
num1, num2 := 666 // 报错
fmt.Printf("%d, %d\n", num1, num2)
}
- 通过:=同时定义多个变量, 只要任意一个变量没有定义过,都会做退化赋值操作
package main
import "fmt"
//value := 789
func main() {
// 退化赋值现象
num := 123
//num := 456 // 报错
// 如果通过:=定义多个变量, 但是多个变量中有的变量已经在前面定义过了, 那么只会对没有定义过的变量执行:=, 而定义过的变量只执行=操作
// 1. var value int
// 2. num = 456
// 3. value = 789
num, value := 456, 789
fmt.Printf("%d, %d", num, value)
}
Go语言常量
package main
import "fmt"
func main() {
/*
1.在C语言中可以通过const来定义常量
2.在Go语言中一样
3.格式:
const 变量名称 数据类型 = 值;
注意点:
1.数据类型可以省略,默认是int类型,但是const不能省略
2.定义常量不能使用 := , := 是专门用于定义局部变量的
3.定义局部变量没有使用, 编译会报错, 定义全局变量和常量没有使用, 不会报错
4.在Go语言中可以连续定义多个变量, 所以也可以连续定义多个常量
格式:
const 变量名称1, 变量名称2 数据类型 = 值1, 值2;
const(
变量名称1 数据类型 = 值1
变量名称2 数据类型 = 值2
)
5.常量组的注意点
在常量组中, 如果常量没有赋值, 那么默认值就是上一行的取值
*/
//1.定义常量
const num int64 = 10
fmt.Println(num)
fmt.Printf("%T\n", num) //int64
//2. 可以省略数据类型
const num2 = 20
fmt.Println(num2)
fmt.Printf("%T\n", num2) //int
//定义常量不使用
const num3 = 10 //不使用不会报错
//定义多个常量
const a, b, c = 120, 20 ,30
fmt.Println(a,b,c)
//使用常量组定义多个常量,可以直接赋值,并且可以省略数据类型默认就是int类型
const(
d = 10
e //没有赋值默认就是上一行的值
)
fmt.Println(d,e)
fmt.Printf("%T\n", d) //int
//使用常量组定义多个常量
const(
f,g = 10, 20
i,j //默认和上一行一样的值
)
fmt.Println(f,g)
fmt.Println(i,j)
}
