Go 语言自定义类型与指针
Go 语言指针
Go 语言指针
变量是一种使用方便的占位符，用于引用计算机内存地址。
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
package main
import "fmt"
func main() {
var a int = 10
fmt.Printf("%x
", &a)
}
//c000010090
什么是指针
一个指针变量指向了一个值的内存地址。
类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：
var var_name *var-type
var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。以下是有效的指针声明：
var ip *int /* 指向整型*/
var fp *float32 /* 指向浮点型 */
如何使用指针
指针使用流程：
- 定义指针变量。
- 为指针变量赋值。
- 访问指针变量中指向地址的值。
在指针类型前面加上 * 号（前缀）来获取指针所指向的内容
package main
import "fmt"
func main() {
var a int = 20
var ip *int //声明一个整型的指针
ip = &a
fmt.Println(*ip) //通过指针访问地址
fmt.Printf("%x
", &a) // a变量的内存地址
fmt.Println(ip) //ip存储的是a变量的内存地址
fmt.Printf("%x
", ip)
}
"""
20
c000010090
0xc000010090
c000010090
"""
创建指针
new(类型)
new() 函数可以创建一个对应类型的指针，创建过程会分配内存，被创建的指针指向默认值
package main
import "fmt"
func main() {
str := new(string)
*str = "hello"
fmt.Println(*str)
}
PS D:goprogramgosrcday05> go run .lianxi.go
hello
Go 空指针
当一个指针被定义后没有分配到任何变量时，它的值为 nil。
nil 指针也称为空指针。
nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
一个指针变量通常缩写为 ptr。
查看以下实例：
package main
import "fmt"
func main() {
var p *int
fmt.Printf("%x
", p)
fmt.Printf("%d
", *p)
}
"""
0
panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xc0000005 code=0x0 addr=0x0 pc=0x49c104]
goroutine 1 [running]:
main.main()
D:/goprogram/go/src/day05/function.go:8 +0x94
"""
当访问空指针时，会报错，因为指针的内存地址为0，避免有空指针
空指针判断：
package main
import "fmt"
func main() {
var p *int
fmt.Printf("%x
", p)
// fmt.Printf("%d
", *p)
if p == nil {
fmt.Println("空指针")
}
}
| 内容 | 描述 |
|---|---|
| Go 指针数组 | 你可以定义一个指针数组来存储地址 |
| Go 指向指针的指针 | Go 支持指向指针的指针 |
| Go 向函数传递指针参数 | 通过引用或地址传参，在函数调用时可以改变其值 |
go指针数组
声明整型指针数组：
var ptr [MAX]*int;
ptr 为整型指针数组。因此每个元素都指向了一个值。以下实例的三个整数将存储在指针数组中：
package main
import "fmt"
const Max int = 3
func main() {
a := []int{10, 100, 200}
var p [Max]*int //声明整型指针数组
for i := 0; i < Max; i++ {
p[i] = &a[i]
}
for i := 0; i < Max; i++ {
fmt.Printf("p[%d] = %d
", i, *p[i])
}
}
"""
p[0] = 10
p[1] = 100
p[2] = 200
"""
创建指针数组的时候，不适合用 range 循环。
错误代码:
package main
import "fmt"
const Max int = 3
func main() {
a := [Max]int{10, 100, 200}
var p [Max]*int //声明整型指针数组
// for i := 0; i < Max; i++ {
// p[i] = &a[i]
// }
// for i := 0; i < Max; i++ {
// fmt.Printf("p[%d] = %d
", i, *p[i])
// }
for i, x := range &a {
p[i] = &x
}
for i, x := range p {
fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%d
", i, *x, x)
}
}
"""
PS D:goprogramgosrcday05> go build -o funtion.exe
PS D:goprogramgosrcday05> .funtion.exe
指针数组：索引:0 值:200 值的内存地址:824633786512
指针数组：索引:1 值:200 值的内存地址:824633786512
指针数组：索引:2 值:200 值的内存地址:824633786512
从结果中我们发现内存地址都一样，而且值也一样。怎么回事？
这个问题是range循环的实现逻辑引起的。跟for循环不一样的地方在于range循环中的x变量是临时变量。range循环只是将值拷贝到x变量中。因此内存地址都是一样的。
"""
正确代码：
package main
import "fmt"
const Max int = 3
func main() {
a := [Max]int{10, 100, 200}
var p [Max]*int //声明整型指针数组
for i := 0; i < Max; i++ {
p[i] = &a[i]
}
// for i := 0; i < Max; i++ {
// fmt.Printf("p[%d] = %d
", i, *p[i])
// }
// for i, x := range &a {
// p[i] = &x
// }
for i, x := range p {
fmt.Printf("指针数组：索引:%d 值:%d 值的内存地址:%d
", i, *x, x)
}
}
"""
PS D:goprogramgosrcday05> go build -o funtion.exe
PS D:goprogramgosrcday05> .funtion.exe
指针数组：索引:0 值:10 值的内存地址:824634122560
指针数组：索引:1 值:100 值的内存地址:824634122568
指针数组：索引:2 值:200 值的内存地址:824634122576
"""
Go 语言指向指针的指针
如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。
当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址：
向指针的指针变量声明格式如下：
var ptr **int;
以上指向指针的指针变量为整型。
访问指向指针的指针变量值需要使用两个 * 号，如下所示：
package main
import "fmt"
const Max int = 3
const (
n1 = iota
)
func main() {
var a int
var p *int
var pp **int
a = 3000
p = &a
pp = &p
fmt.Printf("&a=%x a=%d
", &a, a)
fmt.Printf("p=%x *p=%d
", p, *p)
fmt.Printf("pp=%x *pp=%d
", pp, *pp)
fmt.Printf("**pp=%d
", **pp)
}
运行结果
PS D:goprogramgosrcday05> go build -o funtion.exe
PS D:goprogramgosrcday05> .funtion.exe
&a=c000010090 a=3000
p=c000010090 *p=3000
pp=c000006028 *pp=824633786512
**pp=3000
Go 语言指针作为函数参数
Go 语言允许向函数传递指针，只需要在函数定义的参数上设置为指针类型即可
package main
import "fmt"
const Max int = 3
func swap(x *int, y *int) {
fmt.Println(x)
fmt.Println(y)
var temp int
temp = *x //*(&a)
*x = *y //*(&a)=*(&b)
*y = temp //*(&b) = 100
}
func main() {
var a int = 100
var b int = 200
swap(&a, &b)
fmt.Println(a)
fmt.Println(b)
}
运行结果
0xc000010090
0xc000010098
200
100
简便方式，采用python中的解构
package main
import "fmt"
const Max int = 3
func swap(x *int, y *int) {
// var temp int
// temp = *x //*(&a)
// *x = *y //*(&a)=*(&b)
// *y = temp //*(&b) = 100
// 简便方式
*x, *y = *y, *x
}
func main() {
var a int = 100
var b int = 200
swap(&a, &b)
fmt.Println(a)
fmt.Println(b)
}
案例：使用指针变量获取命令行的输入信息
Go语言内置的 flag 包实现了对命令行参数的解析，flag 包使得开发命令行工具更为简单
package main
import (
"flag"
"fmt"
"os"
)
var mode = flag.String("mode", "", "process mode")
func main() {
//解析命令行参数
fmt.Println(os.Args[1:])
flag.Parse()
fmt.Println(*mode)
}
"""
fast
PS D:goprogramgosrcday05> go run .lianxi.go --mode=fast
[--mode=fast]
fast
PS D:goprogramgosrcday05> go run .lianxi.go --mode=fast t]
[C:Users32639AppDataLocalTempgo-build599453026001exelianxi.exe --mode=fast]
Go 语言结构体
Go 语言结构体
Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合
定义结构体
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：
type struct_variable_type struct {
member definition
member definition
...
member definition
}
一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：
variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
fmt.Println(Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407})
b := Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407}
fmt.Println(b.title)
// 忽略的字段为 0 或 空
fmt.Println(Books{title: "Go 语言", author: "www.runoob.com"})
}
访问结构体成员
如果要访问结构体成员，需要使用点号 . 操作符，格式为：
结构体.成员名"
结构体类型变量使用 struct 关键字定义，实例如下：
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* 声明 Book1 为 Books 类型 */
var Book2 Books /* 声明 Book2 为 Books 类型 */
/* book 1 描述 */
Book1.title = "Go 语言"
Book1.author = "www.runoob.com"
Book1.subject = "Go 语言教程"
Book1.book_id = 6495407
/* book 2 描述 */
Book2.title = "Python 教程"
Book2.author = "www.runoob.com"
Book2.subject = "Python 语言教程"
Book2.book_id = 6495700
/* 打印 Book1 信息 */
fmt.Printf( "Book 1 title : %s
", Book1.title)
fmt.Printf( "Book 1 author : %s
", Book1.author)
fmt.Printf( "Book 1 subject : %s
", Book1.subject)
fmt.Printf( "Book 1 book_id : %d
", Book1.book_id)
/* 打印 Book2 信息 */
fmt.Printf( "Book 2 title : %s
", Book2.title)
fmt.Printf( "Book 2 author : %s
", Book2.author)
fmt.Printf( "Book 2 subject : %s
", Book2.subject)
fmt.Printf( "Book 2 book_id : %d
", Book2.book_id)
}
"""
Book 1 title : Go 语言
Book 1 author : www.runoob.com
Book 1 subject : Go 语言教程
Book 1 book_id : 6495407
Book 2 title : Python 教程
Book 2 author : www.runoob.com
Book 2 subject : Python 语言教程
Book 2 book_id : 6495700
"""
结构体作为函数参数
你可以像其他数据类型一样将结构体类型作为参数传递给函数。并以以上实例的方式访问结构体变量：
**package** main
**import** "fmt"
**type** Books struct {
title string
author string
subject string
book_id int
}
func main() {
**var** Book1 Books */* 声明 Book1 为 Books 类型 */*
**var** Book2 Books */* 声明 Book2 为 Books 类型 */*
*/* book 1 描述 */*
Book1.title = "Go 语言"
Book1.author = "www.runoob.com"
Book1.subject = "Go 语言教程"
Book1.book_id = 6495407
*/* book 2 描述 */*
Book2.title = "Python 教程"
Book2.author = "www.runoob.com"
Book2.subject = "Python 语言教程"
Book2.book_id = 6495700
*/* 打印 Book1 信息 */*
printBook(Book1)
*/* 打印 Book2 信息 */*
printBook(Book2)
}
func printBook( book Books ) {
fmt.Printf( "Book title : %s**
**", book.title)
fmt.Printf( "Book author : %s**
**", book.author)
fmt.Printf( "Book subject : %s**
**", book.subject)
fmt.Printf( "Book book_id : %d**
**", book.book_id)
}
以上实例执行运行结果为：
Book title : Go 语言
Book author : www.runoob.com
Book subject : Go 语言教程
Book book_id : 6495407
Book title : Python 教程
Book author : www.runoob.com
Book subject : Python 语言教程
Book book_id : 6495700
结构体指针
你可以定义指向结构体的指针类似于其他指针变量，格式如下：
var struct_pointer *Books
以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：
struct_pointer = &Book1
使用结构体指针访问结构体成员，使用 "." 操作符：
struct_pointer.title
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func main() {
var Book1 Books /* Declare Book1 of type Book */
var Book2 Books /* Declare Book2 of type Book */
/* book 1 描述 */
Book1.title = "Go 语言"
Book1.author = "www.runoob.com"
Book1.subject = "Go 语言教程"
Book1.book_id = 6495407
/* book 2 描述 */
Book2.title = "Python 教程"
Book2.author = "www.runoob.com"
Book2.subject = "Python 语言教程"
Book2.book_id = 6495700
/* 打印 Book1 信息 */
printBook(&Book1)
/* 打印 Book2 信息 */
printBook(&Book2)
}
func printBook( book *Books ) {
fmt.Printf( "Book title : %s
", book.title)
fmt.Printf( "Book author : %s
", book.author)
fmt.Printf( "Book subject : %s
", book.subject)
fmt.Printf( "Book book_id : %d
", book.book_id)
}
"""
Book title : Go 语言
Book author : www.runoob.com
Book subject : Go 语言教程
Book book_id : 6495407
Book title : Python 教程
Book author : www.runoob.com
Book subject : Python 语言教程
Book book_id : 6495700
"""
结构体是作为参数的值传递：
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func changeBook(book Books) {
book.title = "book1_change"
}
func main() {
var book1 Books
book1.title = "book1"
book1.author = "zuozhe"
book1.book_id = 1
changeBook(book1)
fmt.Println(book1)
}
结果为：
{book1 zuozhe 1}
如果想在函数里面改变结果体数据内容，需要传入指针：
package main
import "fmt"
type Books struct {
title string
author string
subject string
book_id int
}
func changeBook(book *Books) {
book.title = "book1_change"
}
func main() {
var book1 Books
book1.title = "book1"
book1.author = "zuozhe"
book1.book_id = 1
changeBook(&book1)
fmt.Println(book1)
}
结果为：
{book1_change zuozhe 1}
Go 语言常用语法错误
1、开大括号不能放在单独的一行
错误代码：
package main
import "fmt"
func main()
{
fmt.Println("hello world!")
}
编译错误：
./main.go:5:6: missing function body for "main"
./main.go:6:1: syntax error: unexpected semicolon or newline before {
正确代码：
package main
import "fmt"
func main() {
fmt.Println("hello world!")
}
2、未使用的变量
如果你有未使用的局部变量，代码将编译失败。
如果你给未使用的变量分配了一个新的值，代码还是会编译失败。你需要在某个地方使用这个变量，才能让编译器愉快的编译。
错误代码：
package main
var gvar int
func main() {
var one int
two := 2
var three int
three = 3
}
编译错误：
./main.go:6:6: one declared and not used
./main.go:7:9: two declared and not used
./main.go:8:6: three declared and not used
正确代码：
package main
import "fmt"
func main() {
var one int
_ = one
two := 2
fmt.Println(two)
var three int
three = 3
one = three
var four int
four = four
}
// 另外可以选择是注释掉或者移除未使用的变量
3、未使用的Imports
如果你引入一个包，而没有使用其中的任何函数、接口、结构体或者变量的话，代码将会编译失败。
如果你真的需要引入的包，你可以添加一个"_"下划线标记符，来作为这个包的名字，从而避免编译失败。下滑线标记符用于引入，但不使用。
错误代码：
package main
import (
"fmt"
"log"
"time"
)
func main() {
}
编译错误：
./main.go:4:2: imported and not used: "fmt"
./main.go:5:2: imported and not used: "log"
./main.go:6:2: imported and not used: "time"
正确代码：
package main
import (
_ "fmt"
"log"
"time"
)
var _ = log.Println
func main() {
_ = time.Now
}
// 另外可以选择是移除或者注释掉未使用的imports
4、":="简式的变量声明仅可以在函数内部使用
错误代码：
package main
myvar := 1
func main() {
}
编译错误：
./main.go:3:1: syntax error: non-declaration statement outside function body
正确代码：
package main
var myvar = 1
func main() {
}
5、使用简式声明重复声明变量
你不能在一个单独的声明中重复声明一个变量，但在多变量声明中这是允许的，其中至少要有一个新的声明变量。
重复变量需要在相同的代码块内，否则你将得到一个隐藏变量。
错误代码：
package main
func main() {
one := 0
one := 1
}
编译错误：
./main.go:5:6: no new variables on left side of :=
正确代码：
package main
func main() {
one := 0
one, two := 1, 2
one, two = two, one
}
6、Go语言命名区分大小写
错误代码：
package main
import "fmt"
func main() {
fmt.println("Hello world")
}
// 以下代码都是不正确的:
// Package main
// iMport "fmt"
// import "Fmt"
// Func main() {}
// Fmt.Println
// fmt.println
编译错误：
./main.go:6:2: cannot refer to unexported name fmt.println
./main.go:6:2: undefined: fmt.println
正确代码：
package main
import "fmt"
func main() {
fmt.Println("Hello world")
}
7、Go语言中分号分行
错误代码：
package main
import "fmt"
func main() {
fmt.Println("Hello world") fmt.Println("Hi again")
}
编译错误：
./main.go:6:29: syntax error: unexpected fmt at end of statement
正确代码：
package main
import "fmt"
func main() {
fmt.Println("Hello world")
//解决以上问题，可以将上述的两条语句放在两行
fmt.Println("Hi again")
//可以将两条语句用分号结束
fmt.Println("Hello world");fmt.Println("Hi again")
test()
}
func test() {
//因此在Go语言中，分号能省则省，如果必须使用时，添加上也不会出错。
fmt.Println("Hello world");fmt.Println("Hi again");
};
8、Go语言中无效的分号
错误代码：
package main
import "fmt";;
func main() {
fmt.Println("Hello world")
}
编译错误：
./main.go:3:14: syntax error: non-declaration statement outside function body
正确代码：
package main
import "fmt";
func main() {
fmt.Println("Hello world")
}
9、Go语言中注意变量作用域
错误代码：
package main
var num int
func main() {
str := "hello world"
if true {
var b bool
}
println(num)
println(str)
println(b)
}
编译错误：
./main.go:12:10: undefined: b
正确代码：
package main
var num int
func main() {
str := "hello world"
if true {
var b bool
println(b)
}
println(num)
println(str)
}
10、偶然的变量隐藏
短式变量声明的语法如此的方便（尤其对于那些使用过动态语言的开发者而言），很容易让人把它当成一个正常的分配操作。如果你在一个新的代码块中犯了这个错误，将不会出现编译错误，但你的应用将不会做你所期望的事情。
package main
import "fmt"
func main() {
x := 1
fmt.Println(x) // 1
{
fmt.Println(x) // 1
x := 2
fmt.Println(x) // 2
}
fmt.Println(x) // 1
}
运行结果：
1
1
2
1
即使对于经验丰富的Go开发者而言，这也是一个非常常见的陷阱，但又很难发现。
你可以使用 vet命令来发现一些这样的问题。 默认情况下， vet不会执行这样的检查，你需要设置-shadow参数：
命令：go tool vet -shadow your_file.go
go tool vet -shadow main.go
main.go:10: declaration of "x" shadows declaration at main.go:6
11、不使用显式类型，无法使用“nil”来初始化变量
nil标志符用于表示interface、函数、maps、slices和channels的“零值”。如果你不指定变量的类型，编译器将无法编译你的代码，因为它猜不出具体的类型。
错误代码：
package main
func main() {
var x = nil
_ = x
}
编译错误：
./main.go:4:6: use of untyped nil
正确代码：
package main
func main() {
var x interface{} = nil
_ = x
}
12、使用“nil” Slices and Maps
在一个nil的slice中添加元素是没问题的，但对一个map做同样的事将会生成一个运行时的panic。
正确代码：
package main
func main() {
var s []int
s = append(s, 1)
}
错误代码：
package main
import (
"fmt"
)
func main() {
var m map[int]int
m[1] = 1
fmt.Println(m)
}
运行错误：
panic: assignment to entry in nil map
正确代码：
package main
import (
"fmt"
)
func main() {
var m map[int]int
m = make(map[int]int)
m[1] = 1
fmt.Println(m)
}
13、Map的容量
map 只有 len操作， 没有 cap 操作
错误代码：
package main
import (
"fmt"
)
func main() {
m := map[int]string{1: "a", 2: "b", 3: "c"}
cap := cap(m)
fmt.Println(cap)
}
编译错误：
./main.go:9:12: invalid argument m (type map[int]string) for cap
正确代码：
package main
import (
"fmt"
)
func main() {
m := map[int]string{1: "a", 2: "b", 3: "c"}
len := len(m)
fmt.Println(len)
}
14、字符串不会为nil
这对于经常使用nil分配字符串变量的开发者而言是个需要注意的地方。
package main
func main() {
var x string = nil
if x == nil {
x = "default"
}
}
编译错误：
./main.go:4:6: cannot use nil as type string in assignment
./main.go:5:7: invalid operation: x == nil (mismatched types string and nil)
正确代码：
package main
func main() {
var x string
if x == "" {
x = "default"
}
}