Go语言学习（指针与结构体）

最新推荐文章于 2024-08-20 01:09:16 发布
最新推荐文章于 2024-08-20 01:09:16 发布
阅读量172 收藏
点赞数
文章标签： 学习 golang Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43313391/article/details/129109379
版权

指针

指针的概念

Go语言中指针简单易学，使用指针可以更简单的执行一些操作。

变量是一种占位符，底层指向的是一个内存地址。

&取地址符，对于变量a，&a取出这个变量的地址。

指针的使用

  • 定义指针变量

  • 为指针变量赋值 &

  • 指针变量前加上*，来访问指针变量中地址所指向的值

package main

import "fmt"

func main() {
    var a int = 10

    // 声明指针变量，其实就是一个特殊的变量，指向a
    // 定义变量格式 var ptr *类型
    var p *int
    p = &a
    fmt.Printf("a变量的地址：%p\n", &a)   // 0xc00001c0a8
    fmt.Printf("p变量存储的地址：%p\n", p)  // 0xc00001c0a8
    fmt.Printf("p变量自己的地址：%p\n", &p) // 0xc00000a028

    fmt.Println("p变量存储的指针地址指向的值：", *p) // 10
    *p = 20
    fmt.Println(a) // 20 通过指针变量b，改变了a的值
    a = 40
    fmt.Println(*p) // 40

    // 指针的嵌套，指针指向指针，*int就是这个指针对应的类型
    var ptr **int
    ptr = &p
    fmt.Printf("ptr变量存储的指针地址：%p\n", ptr)      // 0xc00000a028
    fmt.Printf("ptr变量自己的地址：%p\n", &ptr)       // 0xc00000a038
    fmt.Printf("*ptr变量存储的指针地址：%p\n", *ptr)    // 0xc00001c0a8
    fmt.Printf("*ptr变量存储的地址指向的值：%d\n", **ptr) // 40
    // 使用指针嵌套，修改变量a的值就有了无数种方式
    **ptr = 50
    fmt.Println(a) // 50
}

数组指针

  • 数组指针：指向数组的指针

  • 指针数组：保存指针的数组

package main

import "fmt"

// 数组指针
func main() {
    // 创建一个数组
    arr1 := [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr1)                   // [1 2 3 4 5]
    fmt.Printf("arr1指向的地址：%p\n", &arr1) // 0xc00000e390

    // 创建一个指针，指向这个数组的地址，通过指针来操作数组
    var p1 *[5]int
    p1 = &arr1
    fmt.Printf("p1指向的地址：%p\n", p1)    // 0xc00000e390
    fmt.Printf("p1自己的地址：%p\n", &p1)   // 0xc00000a030
    fmt.Printf("p1指向的地址的值：%d\n", *p1) // [1 2 3 4 5]

    // 操作数组指针，修改数组
    (*p1)[0] = 100    // 原生写法
    fmt.Println(arr1) // [100 2 3 4 5]
    fmt.Println(*p1)  // [100 2 3 4 5]

    // 语法糖 可以直接用p1来操控数组
    // p1 == arr1
    p1[0] = 100
    fmt.Println(*p1) // [100 2 3 4 5]
    fmt.Println(arr1) // [100 2 3 4 5]
}
package main

import "fmt"

func main() {
    a := 1
    b := 2
    c := 3
    d := 4
    e := 5
    // 创建一个指针数组
    arr1 := [5]*int{&a, &b, &c, &d, &e}
    fmt.Println(arr1) // [0xc000186018 0xc000186030 0xc000186038 0xc000186040 0xc000186048]

    // 通过指针修改a的值
    *arr1[0] = 10
    fmt.Println(a) // 10
}

指针函数

需要是一个函数，这个函数的返回值是一个指针。

package main

import "fmt"

// 指针函数 指针可以用作函数的返回值
func main() {
    p1 := fun()
    fmt.Printf("%p\n", p1)
    fmt.Printf("p1变量的类型：%T\n", p1)        // *[5]int
    fmt.Printf("p1变量的地址：%p\n", &p1)       // 0xc00000a028
    fmt.Printf("p1变量存储的地址指向的值：%d\n", *p1) // [1 2 3 4 5]

    fmt.Println((*p1)[0]) // 1
    p1[0] = 100
    fmt.Println(p1[0]) // 100
}

// 调用该函数，返回的是一个指针
func fun() *[5]int {
    arr := [5]int{1, 2, 3, 4, 5}
    return &arr
}

指针作为函数参数（常用）

package main

import "fmt"

func main() {
    a := 10
    fmt.Println("a变量指向的地址：", &a) // 0xc0000a6058
    fun1(&a)
    fmt.Println(a)               // 20
    fmt.Println("a变量指向的地址：", &a) // 0xc0000a6058
}
func fun1(ptr *int) {
    fmt.Println("ptr 存储的地址：", ptr)      // 0xc0000a6058
    fmt.Println("ptr 自己的地址：", &ptr)     // 0xc0000ca020
    fmt.Println("ptr 存储的地址指向的值：", *ptr) // 10

    *ptr = 20
}

补充：如果没有任何东西在指向变量，变量会被销毁，垃圾回收（GC）。

结构体

变量：定义名字（解决生活中的问题）

判断：分支：true false（解决生活中的问题）

循环：多次操作for（解决生活中的问题）

面向对象编程思维OOP：将世界上的所有物体，抽象成一个一个的类（属性、方法）

用一个变量定义一个人的信息：map[string]string slice

人：属性（name、sex、age）动作（eat() work() sleep()）

结构体定义

package main

import "fmt"

// 定义结构体 type 结构体名 struct
type User struct {
    name string
    age  int
    sex  string
}

func main() {
    // 创建结构体对象的方式一
    var user1 User
    // 定义了结构体对象，但不赋值，默认是结构体的零值 {"" 0 ""}
    fmt.Println(user1) // { 0 }
    user1.name = "张三"
    user1.age = 18
    user1.sex = "男"
    fmt.Println(user1) // {张三 18 男}
    // 获取名字
    fmt.Println(user1.name) // 张三

    // 创建结构体对象的方式二
    user2 := User{}
    user2.name = "李四"
    user2.age = 20
    user2.sex = "女"
    fmt.Println(user2) // {李四 20 女}

    // 创建结构体对象的方式三
    user3 := User{
        name: "王五",
        age:  40,
        sex:  "男",
    }
    fmt.Println(user3) // {王五 40 男}

    // 创建结构体对象的方式四(这种不声明属性的方式，赋值时需要参数一一匹配)
    user4 := User{"小明", 25, "男"}
    fmt.Println(user4) // {小明 25 男}
}

结构体指针

package main

import "fmt"

// 定义结构体
type User2 struct {
    name string
    age  int
    sex  string
}

func main() {
    user1 := User2{"张三", 18, "男"}
    fmt.Println(user1) // {张三 18 男}
    // 结构体类型  包.struct名
    fmt.Printf("%T, %p\n", user1, &user1) // main.User2, 0xc00007e4b0

    // 结构体是值类型的
    user2 := user1
    fmt.Println(user2)                    // {张三 18 男}
    fmt.Printf("%T, %p\n", user2, &user2) // main.User2, 0xc00007e540

    user2.name = "李四"
    fmt.Println(user1) // {张三 18 男}
    fmt.Println(user2) // {李四 18 男}
    fmt.Println("=========================")

    // 可以用指针解决值传递的问题
    var user_ptr *User2
    user_ptr = &user1
    // *user_ptr 等价于 user1
    fmt.Println(*user_ptr) // {张三 18 男}
    (*user_ptr).name = "王五"
    fmt.Println(user1) // {王五 18 男}

    // 语法糖
    user_ptr.name = "王五111"
    fmt.Println(user1) // {王五111 18 男}

    // 利用内置函数 new 创建对象。
    // new 关键字创建的对象，返回指针，而不是返回结构体对象
    // 通过这种方式创建的结构体对象更加灵活，突破了结构体值类型的限制
    user3 := new(User2)
    fmt.Println(user3) // &{ 0 }
    (*user3).name = "小明"
    user3.age = 25
    user3.sex = "男"
    fmt.Println(user3) // &{小明 25 男}

    updateUser(user3)
    fmt.Println(user3) // &{小明 20 男}
}
func updateUser(user *User2) {
    user.age = 20
}

匿名结构体

package main

import "fmt"

type Student struct {
    name string
    age  int
}

func main() {
    s1 := Student{"张三", 18}
    fmt.Println(s1) // {张三 18}

    // 匿名结构体 没有名字的结构体，直接可以在函数内部创建出来，创建后就需要赋值使用
    s2 := struct {
        name string
        age  int
    }{
        "李四",
        20,
    }
    fmt.Println(s2.name, s2.age) // 李四 20

    // 匿名字段
    t1 := Teacher{"李四", 25}
    fmt.Println(t1) // {李四 25}
    // 如何打印这个匿名字段，默认使用数据类型当做字段名称
    fmt.Println(t1.string) // 李四
    fmt.Println(t1.int) // 25
}

// 结构体中的匿名字段，没有名字的字段，这时属性类型不能重复
type Teacher struct {
    string
    int
}

结构体嵌套

复杂对象构建，可以这么定义

package main

import "fmt"

// 一个结构体可能包含一个字段，而这个字段又是一个结构体，结构体嵌套
type Person struct {
    name    string
    age     int
    address Address
}
type Address struct {
    city, state string
}

// 结构体是可以嵌套的，这样就可以定义更多复杂的对象进行拼接，构成一个更大的对象
func main() {
    var person = Person{}
    person.name = "张三"
    person.age = 18
    person.address = Address{
        city:  "安庆",
        state: "中国",
    }
    fmt.Println(person.name)         // 张三
    fmt.Println(person.age)          // 18
    fmt.Println(person.address)      // {安庆 中国}
    fmt.Println(person.address.city) // 安庆
}

结构体导出

public 公开的，所有地方都可以使用；private 私有的，只能自己使用

如果结构体名称首字母小写，则结构体不能被导出使用。即使结构体成员字段名首字母大写，也不会被导出。

如果结构体名称首字母大写，则结构体可以被导出使用。但只对成员字段首字母大写导出使用，对于首字母小写的成员字段不能被导出使用。

如果存在嵌套结构体，即使嵌套在内层的结构体名称首字母小写，外部也能访问到其中首字母大写的成员字段。

结论：结构体名字、属性名字。如果是大写字母，可以被导出使用；如果是小写字母，不可以被导出使用。

张先森yik
关注
【第五讲】GO语言指针和结构体
earthzhang2021的博客
04-24 129
在上一节课程中，我们讨论了如何使用变量和常量。在本节课程中，我们将学习有关指针和结构体的内容。指针是一种非常重要的数据类型，它可以帮助我们管理内存并提高程序的性能。结构体是一种复杂的数据类型，它可以用来组织和管理多个相关的变量。指针的定义和使用方法什么是结构体以及如何使用它们如何通过指针访问结构体成员如何创建和使用指向结构体的指针要定义结构体，请使用type关键字，后跟结构体名称和字段列表。
Go语言中使用结构体和指针
禅与代码的艺术
03-28 1035
介绍在GO语言中如何使用结构体
Go语言结构体指针
qq_54650406的博客
09-14 1404
golang结构体指针
Go语言的使用结构体、指针和方法
DXB2021的博客
01-23 2299
声明并创建一个简单的结构体，程序清单如下： package main import( "fmt" ) type Movie struct{ //结构体 Name string Rating float32 } func main(){ m:=Movie{ Name:"Citizen Kane", Rating:10, } fmt.Println(m.Name,m.Rating) } 运行结果如下： Citizen Kane 10 声明一个类型
Go：指针和结构体
最新发布
Liu_y_xin的博客
08-20 876
Go语言中的指针是一种非常重要的概念，它允许程序员直接访问和操作内存地址，从而可以更高效地管理和传递数据。在Go中，指针相关的知识点主要包括指针的定义、指针的使用、指针与结构体的关系、指针与函数传参等。 Go语言中的结构体（Struct）是一种用户自定义的数据类型，它将不同类型的值组合在一起，形成一个新的复合数据类型。结构体在Go语言中广泛用于组织数据，并可以为其定义方法，使其具备一定的行为能力，相当于其他编程语言中的“类”（但Go不支持类继承），是面向对象编程的基础。
【GO 编程语言】指针与结构体
guanguan12319的博客
07-24 164
【GO 编程语言】指针与结构体
Go指针与结构体
qq_45371023的博客
02-20 305
指针和结构体，指针概念，如何使用。数组指针，指针函数，指针作为参数；结构体，定义一个结构体，匿名结构体，结构体嵌套，结构体导出。
Go语言指针访问结构体的方法
09-22
Go语言指针访问结构体方法的介绍，实际上是要告诉我们在Go中如何使用指针来操作结构体实例的字段。在Go中，结构体的字段可以通过指针直接访问，这种访问是透明的，也就是说你不需要进行解引用操作。这和C++等其他...
Go语言中结构体方法副本传参与指针传参的区别介绍
09-20
在Go语言中，结构体方法的定义分为两种：副本传参和指针传参，这两种方式在使用上有着显著的差异。理解这些差异对于编写高效且无误的Go代码至关重要。 首先，我们要知道Go语言中，当我们调用一个方法时，如果接收者...
Go语言（六）指针及结构体
cgl_dong的博客
10-02 443
Go语言指针及结构体 指针是一种存储地址的数据类型，引用类型；结构体是一种能够组合各种数据类型的类型，值类型。 指针是存储地址的类型，c/c++里面的指针极度强大，通过对指针的偏移、运算和转换 ，是C/C++ 语言拥有极高性能的根本所在，在操作大块数据和做偏移时即方便又便捷，但是C/C++ 中指针饱受诟病，根本原因是指针的运算和内存释放，经常造成内存溢出等问题。 Go语言也提供了指针，但是不允...
golang学习笔记（十一）：指针的定义和使用、数组指针、指针数组、结构体指针
teng_liang的博客
12-29 258
go 指针 数组 结构体
Go 指针数组、指针参数、指针函数及结构体指针
Sunny_Future的博客
07-13 2384
指针是存储另一个变量的内存地址的变量。区别于C/C++中的指针，在Go中的指针不能进行偏移和运算，是安全指针。 1、指针地址、指针类型、指针取值 在Go中的指针操作非常简单，只需要记住两个符号：&（取地址）和*（根据地址取值）。Golang 支持指针类型 *T，指针的指针 **T，以及包含包名前缀的 *.T。 • 默认值 nil，没有 NULL 常量。 • 操作符 "&" （取地址符） 取变量地址，"*" （取值符）透过指针访问目标对象。 • 不支持指针运算，不支持 "->" 运算符，
Go语言学习(五)---指针、类型定义、结构体、方法、接口
qq_56540305的博客
10-23 541
2.2类型定义2.3类型别名示例import ("fmt"/*golang类型定义和类型别名*///类型定义i=100fmt.Printf("i:%T\n",i) //i:main.MyInt i的类型是MyINt不再是int//类型别名j=100import ("fmt"/*golang结构体*///定义id intage int//声明一个结构体变量fmt.Printf("tom:%v\n", tom) //tom:{0 0} 没有初始化时，每个成员都是最初的值。
Golang基础5-指针、结构体、方法、接口
m0_61973596的博客
04-24 1045
Golang基础5-指针、结构体、方法、接口
Go_指针的使用、数组指针和指针数组、指针与切片、指针与结构体、多级指针
itzhuzhu的博客
01-31 2192
指针是一个特殊的变量，因为存储的数据不仅仅是一个普通的数据，而是一个变量的内存地址
如何避免Golang结构体嵌套格式化输出指针地址
一只努力的微服务
05-11 3387
go结构体存在嵌套结构体时，使用%+v格式化输出时会出现打印指针地址的问题，如： type Student struct{ Name string Desp string } type Teacher struct{ Student []*Student Name string } func main() { teacher := new(Teacher) teacher.Name...
一文了解 Go 中的指针和结构体
cmy_top的博客
11-25 1574
前面的两篇文章对 Go 语言的基础语法和基本数据类型以及几个复合数据类型进行介绍，本文将对 Go 里面的指针和结构体进行介绍，也为后续文章做铺垫。
go反射获取类型对象与值、go反射获取指针名称和类型、golang反射对象的空值处理、golang反射值对象修改变量的值
点点的博客
02-23 9504
一、反射获取类型对象与值 package main import ( "fmt" "reflect" ) func main() { a := 36 atype := reflect.TypeOf(a) fmt.Println(atype.Name()) //获取类型名称为int avalue := reflect.ValueOf(a) fmt.Println(avalue.Int()) //获取具体的数值 } 二、反射获取结构体类型名称与类型 package main import
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值