目录
前言
Go语言中new和make都是用来内存分配的原语(allocation primitives)。简单的说,new只分配内存,不初始化内存;make用于slice,map,和channel的初始化
- make和new都是golang用来分配内存的內建函数,且在堆上分配内存,make 即分配内存,也初始化内存。new只是将内存清零,并没有初始化内存。
- make返回的还是引用类型本身;而new返回的是指向类型的指针。
- make只能用来分配及初始化类型为slice,map,channel的数据;new可以分配任意类型的数据。(slice,map,channel三个都是使用前必须初始化的数据结构。例如,slice是一个三元描述符,包含一个指向数据(在数组中)的指针,长度,以及容量,在这些项被初始化之前,slice都是nil的。对于slice,map和channel,make初始化这些内部数据结构,并准备好可用的值。)
new
new的基础用法
new(T) 可以创建 T 类型的变量(这里 T 表示类型),初始值为 T 类型的零值,返回值为其地址(地址类型是 *T)。
v := new(int)
fmt.Println(v, *v) // 0xc00001a098 0
func main() {
// 每次调用 new 函数都会返回唯一的地址变量
p1 := new(int)
q1 := new(int)
fmt.Println(p1, q1, p1 == q1) // 0xc00001c0b8 0xc00001c0c0 false
// 但是也会有例外,当定义一个空 struct 时,通过 new 创建一个变量时,返回的地址是相同的。
s1 := new(Point)
s2 := new(Point)
fmt.Println(s1)
fmt.Println(s2)
fmt.Println(s1 == s2)
}
type Point struct{}
new(基本数据类型)
new(T)函数是一个分配内存的内建函数。对于一个已经存在变量,可对其指针进行赋值。
思考:
// 这样写没有问题
var p int
var v *int
v = &p
*v = 11
fmt.Println(*v)
再次思考:如果不是已经存在的变量会如何呢?能对其直接赋值吗?
var v *int
*v = 12
fmt.Println(*v) // 运行时错误:无效的内存地址或无指针取消引用
// 解决办法:在第二行加上
var v *int
v = new(int)
*v = 12
fmt.Println(*v)
为什么这样做就可以?分析:
可以看到第三行v的值是nil,nil是不可以直接赋值的,我们通过new,返回一个指向新分配的类型为int的指针,因为是用new创建的,所以这个指针指向的内容默认为0
var v *int
// fmt.Println(*v) // 会报错 runtime error: invalid memory address or nil pointer dereference(运行时错误:无效的内存地址或无指针取消引用 )
fmt.Println(v) // <nil>
// 我们通过new 让v指向了一个新分配的类型为int的指针,值默认为0
v = new(int)
fmt.Println(*v) // 0
fmt.Println(v) // 0xc000128010
注意:不同的指针类型零值是不同的
type Name struct {
P string
}
var av *[5]int
var iv *int
var sv *string
var tv *Name
fmt.Println(av) // 值是nil,直接输出 *_,四个都会报错
// fmt.Println(*av)
// fmt.Println(*iv)
// fmt.Println(*sv)
// fmt.Println(*tv)
av = new([5]int)
fmt.Println(*av) // [0 0 0 0 0 0]
iv = new(int)
fmt.Println(*iv) // 0
sv = new(string)
fmt.Println(*sv) //
tv = new(Name)
fmt.Println(*tv) // {}
new(复合类型)
(数组,slice,map,channel等)
数组示例
var a [5]int
fmt.Printf("a: %p %#v \n", &a, a)//a: 0xc04200a180 [5]int{0, 0, 0, 0, 0}
av := new([5]int)
fmt.Printf("av: %p %#v \n", &av, av)//av: 0xc000074018 &[5]int{0, 0, 0, 0, 0}
(*av)[1] = 8
fmt.Printf("av: %p %#v \n", &av, av)//av: 0xc000006028 &[5]int{0, 8, 0, 0, 0}
silce 示例
var a *[]int
fmt.Printf("a: %p %#v \n", &a, a) //a: 0xc042004028 (*[]int)(nil)
av := new([]int)
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000074018 &[]int(nil)
(*av)[0] = 8
fmt.Printf("av: %p %#v \n", &av, av) //panic: runtime error: index out of range
map 示例
var m map[string]string
fmt.Printf("m: %p %#v \n", &m, m)//m: 0xc042068018 map[string]string(nil)
mv := new(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc000006028 &map[string]string(nil)
(*mv)["a"] = "a"
fmt.Printf("mv: %p %#v \n", &mv, mv)//这里会报错panic: assignment to entry in nil map
channel示例
cv := new(chan string)
fmt.Printf("cv: %p %#v \n", &cv, cv)//cv: 0xc000074018 (*chan string)(0xc000074020)
//cv <- "good" //会报 invalid operation: cv <- "good" (send to non-chan type *chan string)
通过上面示例我们看到数组通过new处理,数组av初始化零值,数组虽然是复合类型,但不是引用类型,其他silce、map、channel类型也属于引用类型,go会给引用类型初始化为nil,nil是不能直接赋值的。并且不能用new分配内存。无法直接赋值。那么用make函数处理会是怎么样呢?
make
av := make([]int, 5)
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000046400 []int{0, 0, 0, 0, 0}
av[0] = 1
fmt.Printf("av: %p %#v \n", &av, av) //av: 0xc000046400 []int{1, 0, 0, 0, 0}
mv := make(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv) //mv: 0xc000074020 map[string]string{}
mv["m"] = "m"
fmt.Printf("mv: %p %#v \n", &mv, mv) //mv: 0xc000074020 map[string]string{"m":"m"}
chv := make(chan string)
fmt.Printf("chv: %p %#v \n", &chv, chv) //chv: 0xc000074028 (chan string)(0xc00003e060)
go func(message string) {
chv <- message // 存消息
}("Ping!")
fmt.Println(<-chv) // 取消息 //"Ping!"
close(chv)
make不仅可以开辟一个内存,还能给这个内存的类型初始化其零值。它和new还能配合使用
var mv *map[string]string
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc042004028 (*map[string]string)(nil)
mv = new(map[string]string)
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc000006028 &map[string]string(nil)
(*mv) = make(map[string]string)
(*mv)["a"] = "a"
fmt.Printf("mv: %p %#v \n", &mv, mv)//mv: 0xc042004028 &map[string]string{"a":"a"}
通过new给指针变量mv分配了一个内存,并赋予其内存地址。Map是引用类型,其零值为nil,使用make初始化 map,然后变量就能使用*给指针变量mv赋值了。
另一个例子:
// new 只分配内存,不初始化
p := new([]int) // p == nil; with len and cap 0,被置零的slice结构体的指针,即指向值为nil的slice的指针
fmt.Println(p)
// make 分配内存,也初始化
v := make([]int, 10, 50) // v is initialed with len 10, cap 50
fmt.Println(v)
// &[]
// [0 0 0 0 0 0 0 0 0 0]
new1 := new([2]int)
fmt.Println(new1)
new1[0] = 1
new1[1] = 2
fmt.Println(new1)
// &[0 0]
// &[1 2]