10天入门go语言教程- 指针

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了10天入门go语言教程- 指针，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11510字，纯文字阅读大概需要17分钟。

内容图文

转载请注明来源"老男孩IT教育"
来源网址：https://www.sholdboyedu.com/new/543.html

Go 语言结构体 Go 语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。那么如何更好的学习go语言结构体呢，下面我们一起来看看吧！

什么是结构体？

结构体是用户定义的类型，表示若干个字段（Field）的集合。有时应该把数据整合在一起，而不是让这些数据没有联系。这种情况下可以使用结构体。

例如，一个职员有 firstName、lastName 和 age 三个属性，而把这些属性组合在一个结构体 employee 中就很合理。

结构体的声明

type Employee struct {

firstName string

lastName string

age int

}

在上面的代码片段里，声明了一个结构体类型 Employee，它有 firstName、lastName 和 age 三个字段。通过把相同类型的字段声明在同一行，结构体可以变得更加紧凑。在上面的结构体中，firstName 和 lastName 属于相同的 string 类型，于是这个结构体可以重写为：

type Employee struct {

firstName, lastName string

age, salary int

}

上面的结构体 Employee 称为命名的结构体（Named Structure）。我们创建了名为 Employee 的新类型，而它可以用于创建 Employee 类型的结构体变量。

声明结构体时也可以不用声明一个新类型，这样的结构体类型称为匿名结构体（Anonymous Structure）。

var employee struct {

firstName, lastName string

age int

}

上述代码片段创建一个匿名结构体 employee。

创建命名的结构体

通过下面代码，我们定义了一个命名的结构体 Employee。

package main

import (

"fmt"

)

type Employee struct {

firstName, lastName string

age, salary int

}

func main() {

//creating structure using field names

emp1 := Employee{

firstName: "Sam",

age: 25,

salary: 500,

lastName: "Anderson",

}

//creating structure without using field names

emp2 := Employee{"Thomas", "Paul", 29, 800}

fmt.Println("Employee 1", emp1)

fmt.Println("Employee 2", emp2)

}

在上述程序的第 7 行，我们创建了一个命名的结构体 Employee。而在第 15 行，通过指定每个字段名的值，我们定义了结构体变量 emp1。字段名的顺序不一定要与声明结构体类型时的顺序相同。在这里，我们改变了 lastName 的位置，将其移到了末尾。这样做也不会有任何的问题。

在上面程序的第 23 行，定义 emp2 时我们省略了字段名。在这种情况下，就需要保证字段名的顺序与声明结构体时的顺序相同。

该程序将输出：

Employee 1 {Sam Anderson 25 500}

Employee 2 {Thomas Paul 29 800}

创建匿名结构体

package main

import (

"fmt"

)

func main() {

emp3 := struct {

firstName, lastName string

age, salary int

}{

firstName: "Andreah",

lastName: "Nikola",

age: 31,

salary: 5000,

}

fmt.Println("Employee 3", emp3)

}

在上述程序的第 3 行，我们定义了一个匿名结构体变量 emp3。上面我们已经提到，之所以称这种结构体是匿名的，是因为它只是创建一个新的结构体变量 em3，而没有定义任何结构体类型。

该程序会输出：

Employee 3 {Andreah Nikola 31 5000}

结构体的零值（Zero Value）

当定义好的结构体并没有被显式地初始化时，该结构体的字段将默认赋为零值。

package main

import (

"fmt"

)

type Employee struct {

firstName, lastName string

age, salary int

}

func main() {

var emp4 Employee //zero valued structure

fmt.Println("Employee 4", emp4)

}

该程序定义了 emp4，却没有初始化任何值。因此 firstName 和 lastName 赋值为 string 的零值（""）。而 age 和 salary 赋值为 int 的零值（0）。该程序会输出：

Employee 4 { 0 0}

当然还可以为某些字段指定初始值，而忽略其他字段。这样，忽略的字段名会赋值为零值。

package main

import (

"fmt"

)

type Employee struct {

firstName, lastName string

age, salary int

}

func main() {

emp5 := Employee{

firstName: "John",

lastName: "Paul",

}

fmt.Println("Employee 5", emp5)

}

在上面程序中的第 14 行和第 15 行，我们初始化了 firstName 和 lastName，而 age 和 salary 没有进行初始化。因此 age 和 salary 赋值为零值。该程序会输出：

Employee 5 {John Paul 0 0}

访问结构体的字段

点号操作符 . 用于访问结构体的字段。

package main

import (

"fmt"

)

type Employee struct {

firstName, lastName string

age, salary int

}

func main() {

emp6 := Employee{"Sam", "Anderson", 55, 6000}

fmt.Println("First Name:", emp6.firstName)

fmt.Println("Last Name:", emp6.lastName)

fmt.Println("Age:", emp6.age)

fmt.Printf("Salary: $%d", emp6.salary)

}

上面程序中的 emp6.firstName 访问了结构体 emp6 的字段 firstName。该程序输出：

First Name: Sam

Last Name: Anderson

Age: 55

Salary: $6000

还可以创建零值的 struct，以后再给各个字段赋值。

package main

import (

"fmt"

)

type Employee struct {

firstName, lastName string

age, salary int

}

func main() {

var emp7 Employee

emp7.firstName = "Jack"

emp7.lastName = "Adams"

fmt.Println("Employee 7:", emp7)

}

在上面程序中，我们定义了 emp7，接着给 firstName 和 lastName 赋值。该程序会输出：

Employee 7: {Jack Adams 0 0}

结构体的指针

还可以创建指向结构体的指针。

package main

import (

"fmt"

)

type Employee struct {

firstName, lastName string

age, salary int

}

func main() {

emp8 := &Employee{"Sam", "Anderson", 55, 6000}

fmt.Println("First Name:", (*emp8).firstName)

fmt.Println("Age:", (*emp8).age)

}

在上面程序中，emp8 是一个指向结构体 Employee 的指针。(*emp8).firstName 表示访问结构体 emp8 的 firstName 字段。该程序会输出：

First Name: Sam

Age: 55

Go 语言允许我们在访问 firstName 字段时，可以使用 emp8.firstName 来代替显式的解引用 (*emp8).firstName。

package main

import (

"fmt"

)

type Employee struct {

firstName, lastName string

age, salary int

}

func main() {

emp8 := &Employee{"Sam", "Anderson", 55, 6000}

fmt.Println("First Name:", emp8.firstName)

fmt.Println("Age:", emp8.age)

}

在上面的程序中，我们使用 emp8.firstName 来访问 firstName 字段，该程序会输出：

First Name: Sam

Age: 55

匿名字段

当我们创建结构体时，字段可以只有类型，而没有字段名。这样的字段称为匿名字段（Anonymous Field）。

以下代码创建一个 Person 结构体，它含有两个匿名字段 string 和 int。

type Person struct {

string

int

}

我们接下来使用匿名字段来编写一个程序。

package main

import (

"fmt"

)

type Person struct {

string

int

}

func main() {

p := Person{"Naveen", 50}

fmt.Println(p)

}

在上面的程序中，结构体 Person 有两个匿名字段。p := Person{"Naveen", 50} 定义了一个 Person 类型的变量。该程序输出 {Naveen 50}。

虽然匿名字段没有名称，但其实匿名字段的名称就默认为它的类型。比如在上面的 Person 结构体里，虽说字段是匿名的，但 Go 默认这些字段名是它们各自的类型。所以 Person 结构体有两个名为 string 和 int 的字段。

package main

import (

"fmt"

)

type Person struct {

string

int

}

func main() {

var p1 Person

p1.string = "naveen"

p1.int = 50

fmt.Println(p1)

}

在上面程序的第 14 行和第 15 行，我们访问了 Person 结构体的匿名字段，我们把字段类型作为字段名，分别为 "string" 和 "int"。上面程序的输出如下：

{naveen 50}

嵌套结构体（Nested Structs）

结构体的字段有可能也是一个结构体。这样的结构体称为嵌套结构体。

package main

import (

"fmt"

)

type Address struct {

city, state string

}

type Person struct {

name string

age int

address Address

}

func main() {

var p Person

p.name = "Naveen"

p.age = 50

p.address = Address {

city: "Chicago",

state: "Illinois",

}

fmt.Println("Name:", p.name)

fmt.Println("Age:",p.age)

fmt.Println("City:",p.address.city)

fmt.Println("State:",p.address.state)

}

上面的结构体 Person 有一个字段 address，而 address 也是结构体。该程序输出：

Name: Naveen

Age: 50

City: Chicago

State: Illinois

提升字段（Promoted Fields）

如果是结构体中有匿名的结构体类型字段，则该匿名结构体里的字段就称为提升字段。这是因为提升字段就像是属于外部结构体一样，可以用外部结构体直接访问。我知道这种定义很复杂，所以我们直接研究下代码来理解吧。

type Address struct {

city, state string

}

type Person struct {

name string

age int

Address

}

在上面的代码片段中，Person 结构体有一个匿名字段 Address，而 Address 是一个结构体。现在结构体 Address 有 city 和 state 两个字段，访问这两个字段就像在 Person 里直接声明的一样，因此我们称之为提升字段。

package main

import (

"fmt"

)

type Address struct {

city, state string

}

type Person struct {

name string

age int

Address

}

func main() {

var p Person

p.name = "Naveen"

p.age = 50

p.Address = Address{

city: "Chicago",

state: "Illinois",

}

fmt.Println("Name:", p.name)

fmt.Println("Age:", p.age)

fmt.Println("City:", p.city) //city is promoted field

fmt.Println("State:", p.state) //state is promoted field

}

在上面代码中的第 26 行和第 27 行，我们使用了语法 p.city 和 p.state，访问提升字段 city 和 state 就像它们是在结构体 p 中声明的一样。该程序会输出：

Name: Naveen

Age: 50

City: Chicago

State: Illinois

导出结构体和字段

如果结构体名称以大写字母开头，则它是其他包可以访问的导出类型（Exported Type）。同样，如果结构体里的字段首字母大写，它也能被其他包访问到。

让我们使用自定义包，编写一个程序来更好地去理解它。

在你的 Go 工作区的 src 目录中，创建一个名为 structs 的文件夹。另外在 structs 中再创建一个目录 computer。

在 computer 目录中，在名为 spec.go 的文件中保存下面的程序。

package computer

type Spec struct { //exported struct

Maker string //exported field

model string //unexported field

Price int //exported field

}

上面的代码片段中，创建了一个 computer 包，里面有一个导出结构体类型 Spec。Spec 有两个导出字段 Maker 和 Price，和一个未导出的字段 model。接下来我们会在 main 包中导入这个包，并使用 Spec 结构体。

package main

import "structs/computer"

import "fmt"

func main() {

var spec computer.Spec

spec.Maker = "apple"

spec.Price = 50000

fmt.Println("Spec:", spec)

}

包结构如下所示：

src

structs

computer

spec.go

main.go

在上述程序的第 3 行，我们导入了 computer 包。在第 8 行和第 9 行，我们访问了结构体 Spec 的两个导出字段 Maker 和 Price。执行命令 go install structs 和 workspacepath/bin/structs，运行该程序。

如果我们试图访问未导出的字段 model，编译器会报错。将 main.go 的内容替换为下面的代码

package main

import "structs/computer"

import "fmt"

func main() {

var spec computer.Spec

spec.Maker = "apple"

spec.Price = 50000

spec.model = "Mac Mini"

fmt.Println("Spec:", spec)

}

在上面程序的第 10 行，我们试图访问未导出的字段 model。如果运行这个程序，编译器会产生错误：spec.model undefined (cannot refer to unexported field or method model)。

结构体相等性（Structs Equality）

结构体是值类型。如果它的每一个字段都是可比较的，则该结构体也是可比较的。如果两个结构体变量的对应字段相等，则这两个变量也是相等的。

package main

import (

"fmt"

)

type name struct {

firstName string

lastName string

}

func main() {

name1 := name{"Steve", "Jobs"}

name2 := name{"Steve", "Jobs"}

if name1 == name2 {

fmt.Println("name1 and name2 are equal")

} else {

fmt.Println("name1 and name2 are not equal")

}

name3 := name{firstName:"Steve", lastName:"Jobs"}

name4 := name{}

name4.firstName = "Steve"

if name3 == name4 {

fmt.Println("name3 and name4 are equal")

} else {

fmt.Println("name3 and name4 are not equal")

}

在上面的代码中，结构体类型 name 包含两个 string 类型。由于字符串是可比较的，因此可以比较两个 name 类型的结构体变量。

上面代码中 name1 和 name2 相等，而 name3 和 name4 不相等。该程序会输出：

name1 and name2 are equal

name3 and name4 are not equal

如果结构体包含不可比较的字段，则结构体变量也不可比较。

package main

import (

"fmt"

)

type image struct {

data map[int]int

}

func main() {

image1 := image{data: map[int]int{

0: 155,

}}

image2 := image{data: map[int]int{

0: 155,

}}

if image1 == image2 {

fmt.Println("image1 and image2 are equal")

}

在上面代码中，结构体类型 image 包含一个 map 类型的字段。由于 map 类型是不可比较的，因此 image1 和 image2 也不可比较。如果运行该程序，编译器会报错：main.go:18: invalid operation: image1 == image2 (struct containing map[int]int cannot be compared)。

内容总结

以上是互联网集市为您收集整理的10天入门go语言教程- 指针全部内容，希望文章能够帮你解决10天入门go语言教程- 指针所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/995946.html

来源：【匿名】

【上一篇】golang-1 Hello, World!【下一篇】php和golang的区别是什么？

更多 ►

【10天入门go语言教程- 指针】教程文章相关的互联网学习教程文章

指针普通类型变量存的就是值，也叫值类型。指针类型存的是地址，即指针的值是一个变量的地址。一个指针只是值所保存的位置，不是所有的值都有地址，但是所有的变量都有。使用指针可以在无需知道变量名字的情况下，间接读取或更新变量的值。获取变量的地址，用&,例如:var a int 获取a的地址:&a，&a(a的地址)这个表达式获取一个指向整型变量的指针，它的类型是整形指针(*int),如果值叫做p,我们说p指向x,或者p包含x的地址，p指向的变量...

8.Go语言基础之指针【代码】【图】

Go语言中的指针不能进行偏移和运算，是安全指针。在了解GO语言中的指针前，首先需要知道三个概念：指针地址、指针类型和指针取值。1.Go语言中的指针任何数据载入内存后，在内存中都有对应的地址，这就是指针。为了保存一个数据在内存中的地址，需要指针变量。比如"好好学习，天天向上"这个字符串写入程序中，程序一启动这句话就加载到内存(假设内存地址为0x123456)，在程序中，把该字符串赋值给变量A，把该字符串的内存地址赋值...

go语言4 指针, 结构体, 方法, 接口, python链式调用【代码】

1 指针//指针：指针是一种存储变量内存地址（Memory Address）的变量。package mainfunc main() {//1 定义指针// 指向int类型的指针（指向什么类型指针，就是在什么类型前加星号）//var a *int//2 指针的零值 nil 引用类型//fmt.Println(a) // <nil>//3 使用指针//var a *int//var b int=100////a指针指向b （取谁的地址，就是在谁前面加一个&）//a=&b//fmt.Println(a)// ////4 了解（骚操作）////var c =&a//var c **int...

10、Go语言基础之指针【代码】【图】

区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针。Go语言中的指针需要先知道3个概念：指针地址、指针类型和指针取值。1、Go语言中的指针任何程序数据载入内存后，在内存都有他们的地址，这就是指针。而为了保存一个数据在内存中的地址，就需要指针变量。Go语言中的指针不能进行偏移和运算，因此Go语言中的指针操作非常简单，只需要记住两个符号：&（取地址）和*（根据地址取值）。2、指针地址和指针类型每个变...

go结构，结构嵌套，接口，指针的测试和结论【代码】

package mainimport ("fmt" )//T是M1接受者，不是实现M2接受者 //*T是M1接受者，也是M2的接受者 //所以T对象不可以赋值给接口对象。*T可以//结论： // 1.结构T实现接口I时，如果想通过方法改变其属性，则需要*T实现I所有方法： // 2.嵌套结构时，编译器会将子结构的属性和方法拷贝给父结构，与子结构无关系了； // 3.赋值给接口对象I1，或者接口作为函数参数时,I1:=&T,因为是*T实现了接口I，否则报错 type T struct {Name string }...

Go -- go语言指针【代码】

package mainimport "fmt"type Test struct {Name string }func change2(t *Test) {t.Name = "2" }func change3(t *Test) {// !! 这里的量尽然改了//注意这里括号//如果直接*t.Name=3 编译不通过报错 invalid indirect of t.Name (type string)//其实在go里面*可以省掉，直接类似change2函数里这样使用。(*t).Name = "3" }func change4(t Test) {t.Name = "5" }func main() {// t 是一个地址t := &Test{Name:"1"}change2(t)fmt...

golang 碎片整理之指针【代码】

golang中保留了C中的值和指针的区别，但对于指针的繁琐用法进行了简化，引入了"引用"的概念，所以在go语言中，你不用担心因为直接操作内存而引起各式各样的错误。运算符只有 & 和，一个是取地址一个是取值（解析地址）。 func main(){var i inti = 1var p *intp = &ifmt.Printf("i=%d,p=%d,*p=%d\n",i,p,*p)*p =2fmt.Printf("i=%d,p=%d,*p=%d\n",i,p,*p)i = 3fmt.Printf("i=%d,p=%d,*p=%d\n",i,p,*p) }output:i=1,p=824634302464,...

Go 指针【代码】

普通指针：*T 对于任意类型 T，它所对应的指针类型就是 *T var i int var ip *intvar s string var sp *stringGo 是强类型，不同类型对应的 *T 不可相互转换、不可相互赋值、不可做比较、普通指针不可参与计算。万能指针：unsafe.Pointer unsafe.Pointer 与 *T 的关系，就好比 interface{} 和 T 的关系，也就是说 unsafe.Pointer 可以承载任意类型的 *T，它们之间可以互相转换，这就赋予了开发者直接操作指定内存的权力（效果不明...

Golang切片，数组，函数，结构体，指针【代码】

切片定义切片 //golang语言切片是对数组的抽象，长度不可改变与数组相比切片长度不固定，可以追加元素，追加可能使切片容量增大//切片初始化 var numbers = make([]int, 3, 5) fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers), cap(numbers), numbers) //len=3 cap=5 slice=[0 0 0]//切片截取//创建切片x := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)//len=9 cap=9 slice...

Golang指针

基本介绍 1）基本数据类型，变量存的就是值，也叫值类型 2）获取变量的地址，用&，比如：var num int ，获取num的地址：&num 3）指针类型，变量存的是一个地址，这个地址指向的空间存的才是值，比如：var ptr *int = &num 4) 获取指针类型所指向的值，使用：*，比如：var ptr *int ，使用 *ptr 获取p指向的值 5) 举例 var num int = 1 var i = 999 var ptr *int = &i

Go语言指针

一、什么是指针一个指针变量指向了一个值的内存地址。二、基本介绍基本数据类型的变量存的是值，也叫值类型指针类型的变量存的是一个地址，这个地址指向的空间存的才是值。例如：var ptr *int 获取变量的地址，用&，例如：var num int，获取num的地址，&num 获取指针类型变量所指向的值，使用*，例如：var ptr int，使用ptr获取ptr指向的值。