Go new 函数

Begindev 编辑部 March 25, 2026

在 Go 语言中，new 函数是进行内存分配的基础工具，尤其是在处理指针时。

与 C 或 C++ 等语言不同，Go 没有 malloc 和 free 这种需要手动管理内存分配和释放的函数，因为 Go 依赖强大的垃圾回收机制 (Garbage Collection) 来自动管理内存。

然而，当你需要为一个变量分配内存，并且打算通过指针来访问它时，new 函数就扮演了至关重要的角色。深刻理解 new 函数，是你高效使用指针、构建复杂数据结构（如链表、树等）的必修课。

1.1 `new` 到底做了什么？

new 函数只接收一个参数：数据类型 (Type)。
它的工作流程非常明确：

找系统要一块足够大的内存，用来存放该类型的值。
将这块内存清零，也就是初始化为该类型的零值 (Zero Value)。
返回一个指向这块全新内存的指针。

通用语法如下：

ptr := new(Type)

这里的 Type 可以是任何合法的 Go 类型，比如 int、string、结构体 (Struct) 或是你自己定义的类型。执行完毕后，ptr 就会是一个指针，指向一个干干净净的、零值状态的新变量。

1.2 零值回顾

时刻牢记，new 会自动把分配的内存初始化为零值。以下是常见类型的零值复习：

int (整数): 0
float64 (浮点数): 0.0
bool (布尔值): false
string (字符串): "" (空字符串)
Pointers (指针): nil

2. `new` 函数基础示例

2.1 为整数 (int) 分配内存

package main

import "fmt"

func main() {
	// 为一个整数分配内存，并获取指向它的指针
	ptr := new(int)
	
	// 打印指针本身的地址，以及它指向的内存里的值
	fmt.Println("指针的内存地址:", ptr)   // 输出类似: 指针的内存地址: 0xc00001a0b8
	fmt.Println("地址里存放的值:", *ptr)  // 输出: 地址里存放的值: 0 (int 的零值)
	
	// 通过解引用，修改该内存位置存放的值
	*ptr = 42
	
	// 打印更新后的值
	fmt.Println("更新后的值:", *ptr)     // 输出: 更新后的值: 42
}

在这个例子中，new(int) 开辟了一块能装下整数的内存。变量 ptr 拿到了这块内存的地址。一开始，里面装的是 0。随后我们用 *ptr 顺着地址找过去，把里面的数据改成了 42。

2.2 为字符串 (string) 分配内存

package main

import "fmt"

func main() {
	// 为字符串分配内存，并获取指针
	strPtr := new(string)
	
	fmt.Println("字符串指针地址:", strPtr)       // 输出类似: 0xc00001a0e0
	fmt.Println("地址里的初始字符串:", *strPtr)  // 输出空行 (因为是空字符串 "")
	
	// 赋一个新字符串给它
	*strPtr = "Hello, Go!"
	
	fmt.Println("更新后的字符串:", *strPtr)      // 输出: 更新后的字符串: Hello, Go!
}

3. 核心对比：`new` vs. `&` (取址符)

新手经常会混淆 new 和 &，虽然它们最后都能让你拿到一个指针，但背后的动作截然不同。

new(Type): 无中生有。在堆内存上开辟一块全新的空间，填入零值，并返回这块新空间的指针。
&variable: 顺藤摸瓜。为一个已经存在的变量创建一个指针。它不会开辟任何新的内存空间。

代码对比：

package main

import "fmt"

func main() {
	// 使用 new
	ptr1 := new(int) // 凭空造了一块新内存
	*ptr1 = 10
	fmt.Println("使用 new:", ptr1, *ptr1) // 输出类似: 使用 new: 0xc00001a0b8 10
	
	// 使用 &
	x := 20          // x 已经是一块分配好内存的真实变量了
	ptr2 := &x       // 提取 x 的现成地址
	fmt.Println("使用 &:", ptr2, *ptr2)   // 输出类似: 使用 &: 0xc000012088 20
}

4. 结合结构体 (Structs) 使用 `new`

在实际开发中，new 最常用来实例化一个新的结构体，并直接返回它的指针。

package main

import "fmt"

// 定义一个 Person 结构体
type Person struct {
	Name string
	Age  int
}

func main() {
	// 使用 new 为 Person 结构体分配内存
	personPtr := new(Person)
	
	// 所有字段都会被初始化为对应的零值
	fmt.Println("初始状态的 Person:", *personPtr) // 输出: 初始状态的 Person: { 0}
	
	// 通过指针访问并修改字段
	personPtr.Name = "Alice" // 💡 注意：Go 极其贴心，这里会自动解引用，不需要写 (*personPtr).Name
	personPtr.Age = 30
	
	fmt.Println("更新后的 Person:", *personPtr) // 输出: 更新后的 Person: {Alice 30}
}

注意观察，虽然 personPtr 是一个指针，但在给字段赋值时我们直接写了 personPtr.Name。这是 Go 语言提供的语法糖，它在底层自动替你完成了解引用操作。

5. 到底什么时候该用 `new`？

虽然 new 很好用，但它并不是 Go 语言中分配内存的唯一或首选方式。请遵循以下指南：

使用 new 的场景： 当你明确需要一个指针，并且希望这块内存里的数据干干净净（全是零值）时。这在你需要把指针传给某个初始化函数时很常见。
优先使用复合字面量 (Composite Literals) 的场景： 当你想在创建结构体的同时，立刻给里面赋予特定的初始值时。这种写法通常可读性更高，也是 Go 社区最推崇的做法。
直接声明变量的场景： 在绝大多数普通的业务逻辑中，直接用 var x int 或 x := 10 声明变量就足够了。Go 的垃圾回收机制会处理好一切，你不需要总是用 new 强行分配指针。

new 与复合字面量的直观对比：

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	// 方式 1：使用 new (先分配零值，再逐个赋值)
	pointPtr := new(Point)
	pointPtr.X = 10
	pointPtr.Y = 20
	fmt.Println("使用 new 创建的点:", *pointPtr) // 输出: {10 20}
	
	// 方式 2：使用复合字面量 (直接创建并赋值，最常见)
	point := Point{X: 30, Y: 40}
	fmt.Println("使用字面量创建的点:", point)       // 输出: {30 40}
	
	// 方式 3：使用字面量 + 取址符 & (一步到位拿到初始化好的指针，极其推荐)
	point2 := &Point{X: 50, Y: 60}
	fmt.Println("使用字面量并直接取址:", *point2) // 输出: {50 60}
}

6. 实战演练：通过指针修改值

使用 new 的一个典型场景是：你需要把变量传给一个函数，并且希望函数内部的修改能切实反映到外部。这就必须传递指针。

package main

import "fmt"

// increment 接收一个整数指针，并将真实数据加 1
func increment(ptr *int) {
	*ptr++ // 解引用并自增
}

func main() {
	// 使用 new 分配一个整数内存，拿到指针
	numPtr := new(int)
	
	// 赋予初始值 5
	*numPtr = 5
	fmt.Println("自增前的值:", *numPtr) // 输出: 自增前的值: 5
	
	// 把指针传给函数
	increment(numPtr)
	
	fmt.Println("自增后的值:", *numPtr) // 输出: 自增后的值: 6
}

因为我们传递的是 numPtr（内存地址），函数直接操作了这块内存，所以外部的值成功变成了 6。

1.1 new 到底做了什么？

1.2 零值回顾

2. new 函数基础示例