^-^
一个后知后觉的追赶者
Go 快速入门（三）
最近更新：2025-02-23   |   字数总计：2.6k   |   阅读估时：10分钟   |   阅读量：次

本文的内容建立在已对 C 和 C++ 熟练掌握的基础之上，主要给出 Go 与 C 和 C++ 之间的不同之处。

指针

Go 中指针的定义方式和 C 类似，基本定义方式为 var ptr *type，一些示例如下。

1
2
3
4
var p1 *int // 指向 int 的指针
var p2 *[10]int // 指向 [10]int 数组的指针
var p3 [10]*int // 指向 int 指针的数组
var p4 *string // 指向 string 的指针

Go 中的取地址操作与 C 中一致，使用 & 操作符，未赋值的指针自动指向 nil（空），示例如下。

1
2
3
var x int = 10
var ptr *int // ptr = nil
ptr = &x

make 与 new

值类型与引用类型

Go 中的变量类型分为值类型及引用类型（指针类型），值类型包含有 bool、数字类型、string和array，引用类型有 slice、map、channel、interface、function。

值类型意味着，当你将其直接传入函数时，所作的修改不会反映到原本的值，而引用类型则会反映到原本的值。Go 中引用类型的底层实现实际为一个带有指针的结构体（典型的就是slice），所以在即使是传值也可以改变原值。

使用 make 和 new

new 用于值类型的创建，类似于 C++ 中的 new，其会返回该类型的指针，示例如下。

1
2
3
4
5
p1 := new(int) // -> 0
p2 := new(float64) // -> 0.0
p3 := new(complex64) // -> 0 + 0i
p4 := new(string) // -> ""
p5 := new([5]int) // -> [0 0 0 0 0]

new 得到的 complex64 / complex128 和 string 指针无法直接对原值修改，这是由 Go 中只读的特性决定的。

make 用于引用类型的创建，其会返回该类型的值，示例如下。

1
2
3
p1 := make([]int, 3, 5) // []int, len = 3, cap = 5
p2 := make(map[string]int, 3) // map[string]int, cap = 3
p3 := make(chan int) // chan

关于通道类型暂且不表。

函数

函数定义

Go 中函数的定义方式类似于 C，基本定义方式为 func func_name([param list]) ([return list]) {}，支持多个返回值。

1
2
3
4
5
func foo(x, y int) (int, int) { // (int, int) 为返回列表
  return x + y, x - y
}
x, y := foo(3, 2)
fmt.Println(x, y) // -> 5 1

函数作为参数

Go 中可以使用函数作为参数。

1
2
3
4
5
6
7
8
9
func foo(x int) int {
	return x
}

func bar(y int, f func(int) int) int {
	return f(y)
}

fmt.Println(bar(3, foo)) // -> 3

函数 foo() 作为参数传入 bar() 函数，注意这里对函数类型的描述方法与格式。

函数作为返回值

Go 中可以使用函数作为返回值，这种方式返回的是匿名函数，可作为闭包。

在 Go 语言中，闭包是指一个函数可以引用其外部作用域的变量，即使该作用域已经结束，变量仍然可以被这个函数访问和修改。换句话说，闭包是带有状态的函数。

1
2
3
4
5
6
7
8
9
10
func foo(i int) func(int) int {
  return func(x int) int {
    i++ // i 为外部状态
    return x + i
  }
}

f := foo(0)
fmt.Println(f(1)) // i = 1, x = 1 -> 2
fmt.Println(f(2)) // i = 2, x = 2 -> 4

函数作为方法

Go 中使用结构体实现 C 中类的作用，使用函数实现类的方法，与普通函数的差别是 func 和函数名之间需要加上结构体传入接收者，下面是一个类方法的实现示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
type Student struct {
  id string
  name string
  age int
}

func (s *Student) add(x string, y int) { // 传结构体址
  s.name = s.name + x
  s.age += y
}

func (s Student) print() (string, string, int) { // 传结构体值
  return s.id, s.name, s.age
}

x := Student{"1", "casey", 0}
x.add("new", 10)
fmt.Println(x.print()) // -> 1 caseynew 10

结构体传入时的命名建议为结构体名的第一个小写字母，例如上面的结构体 Student，那么传入的参数名建议为 s。

对上面的代码稍加修改，x := &Student{"1", "casey", 0}，上面的代码不会出错。对于接收者，Go 会对值类型按需求自动取地址，而对指针类型会按需求自动解引用。注意，仅对结构体方法的接收者起作用。

在 Go 中将结构体作为参数同样有像 C 中那样的拷贝开销，因而需要考虑传入结构体的值还是址。

接口

接口定义与使用

Go 中定义接口的一般方式如下。

1
2
3
4
5
type interface_name interface {
  method1([param list]) ([return list])
  method2([param list]) ([return list])
  ...
}

Go 中的接口实现了一些方法，任何其他类型只要实现了这些方法就是实现了这个接口，没有显式声明。其实可以类比于 C 中没有成员变量，只有成员函数，且成员函数都是纯虚函数的基类，接口就是一个基类指针，其他实现了纯虚函数的类型即继承了这个基类，从而实现了 Go 中的继承与多态。

接口变量实际包含两个部分，一是变量的类型，二是变量本身的值。

以下是一个接口的示例。首先定义一个接口，含有两个方法 Area() 和 Perimeter() 分别求面积和周长。然后定义两个结构体 Circle 和 Rectangle 实现接口的方法，最后通过接口实现对方法的调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
type Shape interface {
  Area() float64
  Perimeter() float64
}

type Circle struct {
  radius float64
}
func (c Circle) Area() float64 {
  return 3.14 * c.radius * c.radius
}
func (c Circle) Perimeter() float64 {
  return 2 * 3.14 * c.radius
}

type Rectangle struct {
  length float64
  width float64
}
func (r Rectangle) Area() float64 {
  return r.length * r.width
}
func (r Rectangle) Perimeter() float64 {
  return 2 * (r.length + r.width)
}

func main() {
  var s Shape // s = nil
  c := Circle{radius: 5}
  r := Rectangle{length: 5, width: 4}
  s = c // 类型为 Circle，值为 c
  fmt.Println(s.Area(), s.Perimeter()) // -> 78.5 31.400000000000002
  s = r // 类型为 Rectangle，值为 r
  fmt.Println(s.Area(), s.Perimeter()) // -> 20 18
}

注意上述代码的两个小细节：

  • 空的接口其值为 nil；
  • 接口在赋值时有两种情况，以 c 为例，有 s = c 和 s = &c 两种，这主要取决于实现接口时用的方法传入的结构体是值还是址。若像上面这样传入结构体的值 func (c Circle) Area() float64 {}，那么使用两种均可（值与址调用），s = &c 会自动解引用；若是传入址 func (c *Circle) Area() float64 {}，则只能用 s = &c 来调用方法（仅能址调用）。这里的情况注意要和结构体的方法进行区分。

空接口

空接口 interface {} 是 Go 中的一种特殊接口，任意类型都实现了空接口，这也就意味着空接口可以指向任何类型，但是无法调用任何方法。

类型断言

类型断言的作用是对一个接口指定某种类型抽取其底层值，基本语法为 val := interface_val.(type)。例如，在上面的接口例子中，将 func main() {} 做些修改。

1
2
3
4
5
func main() {
  var s Shape = Circle{radius: 5}
  r := s.(Rectangle) // panic: interface conversion ...
  fmt.Println(s.Area(), s.Perimeter())
}

r := s.(Rectangle) 即是类型断言，其将 s 底层值指定以 Rectangle 类型抽出。但是显然存在错误，类型不匹配，触发 panic。

为了避免这种问题，应使用带检查的断言，在断言前实现检查，如下。

1
2
3
4
5
6
7
8
9
func main() {
  var s Shape = Circle{radius: 5}
  if r, ok := s.(Rectangle); ok {
    fmt.Println("s is a Rectangle")
  } else {
    fmt.Println("s is not a Rectangle") // 输出
  }
  // r...
}

类型选择

type switch 是一种特殊的 switch 语句，其只作用于接口，用于判断接口当前值的类型。示例如下。

1
2
3
4
5
6
7
var s Shape = Circle{radius: 5}
switch s.(type) {
case Circle:
  fmt.Println("s is a circle") // 输出
case Rectangle:
  fmt.Println("s is a Rectangle")
}

type switch 的同时可以取值，写成 switch val := s.(type) {...}，得到对应类型的值 val。

接口嵌套

接口可以嵌套，但是接口的嵌套在实现上并没有特殊性，因为接口中都是虚函数，只需要依次实现嵌套的接口中所有的方法即实现了该嵌套的接口。以下是一个示例，A 接口嵌套了 B 及 C 接口，结构体 D 实现了 A 中所有的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
type A interface {
  B
  C
}
type B interface {
  B1()
  B2()
}
type C interface {
  C1()
  C2()
}

type D struct{}
func (d *D) B1() {
  fmt.Println("B1")
}
func (d *D) B2() {
  fmt.Println("B2")
}
func (d *D) C1() {
  fmt.Println("C1")
}
func (d *D) C2() {
  fmt.Println("C2")
}

func main() {
  var s A = &D{}
  s.B1()
  s.B2()
  s.C1()
  s.C2()
}

杂项

匿名结构体嵌套调用

以下面的代码为例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
type A struct {
  val int 
}
type B struct {
  A
}
func (a *A) add() {
  a.val++
}

b := B{A{5}}
fmt.Println(b.val) // -> 5
b.A.add() // OK
fmt.Println(b.val) // -> 6
b.add() // OK
fmt.Println(b.val) // -> 7

注意两个细节，b 的初始化方式与 b.add() 这种调用方式。可以发现，结构体 B 中嵌套了一个匿名结构体变量 A，而 A 中又有变量 val，此时可以直接使用 b.val 调用该变量，类似的，也就可以直接调用匿名结构体变量的方法。匿名嵌套的写法会使所有 A 中的字段与方法提升到 B 的作用域，这种行为非常类似于继承。

再看一个例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
type A struct {
  int 
}
func (a *A) add() {
  a.int++
}

type B struct {
  int
  A
}
func (b *B) add() {
  b.int++
}

b := B{2, A{1}}
fmt.Println(b.int, b.A.int) // -> 2 1
b.A.add()
b.add()
fmt.Println(b.int, b.A.int) // -> 3 2

这个例子在上一个例子的基础上将 A 中的变量也置为了匿名变量，同时 A 和 B 存在同名方法 add()。由于匿名结构体 A 的嵌套，使 A 中的 int 被提升到 B 的作用域，此时的 B 中存在有两个匿名 int 变量，但这是合法的，并不会报错。此时，我们需要指明字段名才能访问到 A 中的匿名变量。类似的，当 B 和 A 中存在有相同的方法时，需要指明字段名才能正确调用。

函数返回方式

除了上面介绍的可以直接 return [return list] 之外，还可以确定的指明返回的字段名，然后直接 return，示例如下。

1
2
3
4
5
6
func addsub(a, b int) (c, d int) {
  c = a + b
  d = a - b
  return
}
fmt.Println(addsub(10, 5)) // -> 15 5

这样明确给返回值赋值，可以不用在返回时指明返回值。

接口到底能接收什么

接口既能接收值也能接收址，只要该变量能调用接口中的函数，那么就认为他可以被接口接收，接口可以赋值为该变量。

接口中对象的方法调用

一旦某个对象被存入了接口，之后通过该接口只能调用接口中的方法，对象本身的方法无法调用，若想要调用，需要使用类型断言进行转换。

2025-02-23 该篇文章被 Casey 打上标签: Go 归为分类: 学习

上一篇：文章快速索引 下一篇：Go 快速入门（二）
© 2025 Casey / 📧联系 / ☕支持 / 🔗链接
脚踏实地, 不断追逐 本站由Hexo驱动｜使用Hexo-theme-A4主题