Go基础——指针、结构体

1、指针
Go语言指针与C差不多，取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
变量是一种使用方便的占位符，用于引用计算机内存地址。一个指针变量可以指向任何一个值的内存地址，它所指向的值的内存地址在 32 和 64 位机器上分别占用 4 或 8 个字节，占用字节的大小与所指向的值的大小无关。当一个指针被定义后没有分配到任何变量时，它的默认值为 nil。
每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。

func ptr_test() {
	var a int = 20 /* 声明实际变量 */
	var ip *int    /* 声明指针变量 */

	ip = &a /* 指针变量的存储地址 */

	fmt.Printf("a 变量的地址是: %x\n", &a)

	/* 指针变量的存储地址 */
	fmt.Printf("ip 变量储存的指针地址: %x\n", ip)

	/* 使用指针访问值 */
	fmt.Printf("*ip 变量的值: %d\n", *ip)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

指针也可为空：当一个指针被定义后没有分配到任何变量时，它的值为 nil。

var  ptr *int
fmt.Printf("ptr 的值为 : %x\n", ptr  )

输出：0
1
2
3
4

指向值指针的指针（类似链表）：
如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。
当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址：

func main() {
   var a int
   var ptr *int
   var pptr **int
   a = 3000

   /* 指针 ptr 地址 */
   ptr = &a

   /* 指向指针 ptr 地址 */
   pptr = &ptr

   /* 获取 pptr 的值 */
   fmt.Printf("变量 a = %d\n", a )
   fmt.Printf("指针变量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Go语言里很多调用都是通过指针！

2、结构体
数组可以存储同一类型的数据，但在结构体中可以为不同项定义不同的数据类型。与C语言类似，结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

package main

import "fmt"

type Books struct {
	title   string
	author  string
	subject string
	book_id int
}

func main() {
	var book Books
	CrateStruct()
	NewStruct(&book)
}

func CrateStruct() {
	// 创建一个新的结构体
	fmt.Println(Books{
		"Go",
		"www.aaa.com",
		"Go 基础",
		6495407})

	// 也可以使用 key => value 格式
	fmt.Println(Books{
		title:   "Go",
		author:  "www.aaa.com",
		subject: "Go 基础",
		book_id: 6495407})

	// 忽略的字段为 0 或 空
	fmt.Println(Books{title: "Go", author: "www.aaa.com"})

}

func NewStruct(b *Books) {
	b.title = "Go"
	b.author = "www.aaa.com"
	b.subject = "Go基础"
	b.book_id = 123456
	fmt.Println(b.title) // Go
	fmt.Println(*b)      // {Go www.aaa.com Go基础 123456}
}

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
36
37
38
39
40
41
42
43
44
45
46

Go语言里面还可将结构体与json进行映射：

package main

import (
	"encoding/json"
	"fmt"
	"log"
)
// 定义结构体字段 映射到json时的字段
type Bookss struct {
	Title   string `json:"title"`
	Author  string `json:"author"`
	Subject string `json:"subject"`
	BookID  int    `json:"book_id"`
}

func main() {
	book := Bookss{
		Title:   "Go",
		Author:  "www.aaa.com",
		Subject: "Go 基础",
		BookID:  123456,
	}
	jsonData, err := json.Marshal(book)  //  将结构体转换为json，返回值为byte类型
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println((string(jsonData)))
}

//  输出：{"title":"Go","author":"www.aaa.com","subject":"Go 基础","book_id":123456}
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

正式代码中，函数名、结构体名、结构体属性变量必须首字母大写，否则会视为私有成员，无法进行导出！

3、错误处理

在结构体中使用过err变量处理内置函数的错误返回值，内置函数一般都会有错误返回值，Go语言通过内置的错误接口提供了非常简单的错误处理机制。
error 类型是一个接口类型：

type error interface {
    Error() string
}
1
2
3

编写函数时，可常在最后的返回值中返回错误信息，使用 errors.New 可返回一个错误信息：

func Heelo(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("Hello：No Money!")   // 实际为字符串
    }
}
result, err:= Heelo(-1)
if err != nil {
   fmt.Println(err)
}

1
2
3
4
5
6
7
8
9
10