Golang学习Day3

已于 2023-03-02 17:52:43 修改
阅读量639 收藏
点赞数
分类专栏： Golang 文章标签： golang 学习 开发语言 网络安全 安全 Powered by 金山文档
于 2023-02-25 13:11:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44770698/article/details/129214494
版权
本文介绍了Go语言中的指针操作，包括值传递和指针变量的声明与使用。接着讨论了类型定义和类型别名的区别，以及结构体的声明、初始化和结构体指针的运用。最后，文章讲解了Go语言中方法的定义和接收者类型，以及值类型和指针类型作为接收者时的不同效果。
摘要由CSDN通过智能技术生成 
😋 大家好，我是YAy_17，是一枚爱好网安的小白。
本人水平有限，欢迎各位师傅指点，欢迎关注 😁，一起学习 💗 ，一起进步 ⭐ 。
⭐ 此后如竟没有炬火，我便是唯一的光。 ⭐   

(暂时停更下Golang的学习，忙着准备CTF和蓝桥杯)

Go语言中的指针

Go语言中的函数传参都是值传递，当我们想要修改某个变量的时候，我们可以创建一个指向该变量地址的指针变量，传递数据使用指针，而无需拷贝数据。

类型指针不能进行偏移和运算。

Go语言中的指针操作非常简单，只需要记住两个符号&(取地址)和*（根据地址取值）

指针地址和指针类型

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行取地址操作。Go语言中的值类型(int、float、bool、string、array、struct）都有对应的指针类型，如: *int、 *int64、*string等。

指针的语法

一个指针变量指向了一个值的内存地址。(也就是我们声明了一个指针之后，可以像变量赋值一样，把一个值的内存地址放入到指针当中。)类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下:

var var _name *var_type

var_type :为指针类型 var_name :为指针变量名 *:用于指定变量是作为一个指针。

package main

import "fmt"

func main() {
    var p *int
    fmt.Printf("p: %v\n", p)
    fmt.Printf("p: %T\n", p)
    var a int = 100
    p = &a
    fmt.Printf("p: %v\n", *p)

    var str *string
    fmt.Printf("str: %v\n", str)
    fmt.Printf("str: %T\n", str)
    s := "Y4y17"
    str = &s
    fmt.Printf("str: %v\n", *str)

    var bl *bool
    fmt.Printf("bl: %v\n", bl)
    fmt.Printf("bl: %T\n", bl)
    var b bool = true
    bl = &b
    fmt.Printf("bl: %v\n", *bl)
}

输出结果为：

指向数组的指针

定义语法

var ptr [MAX]*int //表示数组里面的元素的类型是指针类型

package main

import "fmt"

func main() {
    a := [3]int{1, 2, 3}
    var p [3]*int
    fmt.Printf("p: %v\n", p)
    for i := 0; i < len(a); i++ {
        p[i] = &a[i]
        fmt.Printf("p[i]: %v\n", *p[i])
    }
}

输出结果为：

Go语言中的类型定义和类型别名

Go语言类型定义

type Newtype Type

package main
import "fmt"

func main() {
    type Myint int
    var i Myint = 100
    fmt.Printf("i: %T,%v\n", i, i)
}

输出结果如下：

i: main.Myint,100

Go语言类型别名

type Newtype=Type
package main
import "fmt"
func main() {
	type Myint = int
    var i Myint = 100
    fmt.Printf("i: %T,%v\n", i, i)
}
i: int,100

Go语言中的类型定义和类型别名的区别

  1. 类型定义相当于定义了一个全新的类型，与之前的类型不同;但是类型别名并没有定义一个新的类型，而是使用一个别名来替换之前的类型

  1. 类型别名只会在代码中存在，在编译完成之后并不会存在该别名

  1. 因为类型别名和原来的类型是一致的，所以原来类型所拥有的方法，类型别名中也可以调用，但是如果是重新定义的一个类型，那么不可以调用之前的任何方法

Go语言中的结构体

在使用结构体之前我们需要定义一个结构体类型，之后通过定义的这个结构体类型在去定义结构体变量；语法结构如下：

type struct_variable_type struct{
member definition;
member definition;
......
member definition;
}
type:结构体定义关键字
struct_variable_type:结构体类型名称
member definition：成员定义 
package main

import "fmt"

func main() {
    type person struct {
        name string
        age  int
        sex  string
    }
    var tom person
    fmt.Printf("tom: %v\n", tom)
    tom.name = "tom"
    tom.sex = "man"
    tom.age = 20
    fmt.Printf("tom: %v\n", tom)
    fmt.Printf("tom.name: %v\n", tom.name)
}

输出的结果如下：

匿名结构体

package main

import "fmt"

func main() {
    var tom struct {	//匿名结构体在定义的时候不再使用type 而是var
        name string
        age  int
        sex  string
    }
    tom.name = "tom"
    tom.sex = "man"
    tom.age = 20
    fmt.Printf("tom: %v\n", tom)
    fmt.Printf("tom.name: %v\n", tom.name)
}

结构体的初始化

package main

import "fmt"

func main() {
    type person struct {
        name, email string
        age, id     int
    }
    //第一种初始化的方法：键值对的方式
    var tom person
    tom = person{
        name:  "tom",
        email: "tom@gmail.com",
        age:   20,
        id:    111,
    }
    fmt.Printf("tom: %v\n", tom)
    //第二种初始化的方法：列表的方式
    var Y4y17 person
    Y4y17 = person{
        //这种初始化的方法，必须按照结构体成员定义的顺序进行初始化
        "Y4y17",
        "Y4y17@gmail.com",
        20,
        16,
    }
    fmt.Printf("Y4y17: %v\n", Y4y17)
    //第三种初始化的方法：支持短变量赋值
    Mary := person{
        //部分赋值也是可以的
        name: "Mary",
        id:   22,
    }
    fmt.Printf("Mary: %v\n", Mary)
}
输出结果如下：
tom: {tom tom@gmail.com 20 111}
Y4y17: {Y4y17 Y4y17@gmail.com 20 16}
Mary: {Mary  0 22}

结构体指针

package main

import (
    "fmt"
)
//普通的指针变量
func test1() {
    var name string = "Y4y17"
    var nm *string
    nm = &name
    fmt.Printf("name: %v\n", name)
    fmt.Printf("nm: %v\n", nm)
    fmt.Printf("nm: %v\n", *nm)
}
//结构体指针
func test2() {
    type person struct {
        name string
        age  int
        id   int
    }
    var p_struct *person
    //这里存在3种赋值的方式
    //第一种方式：
    p_struct = &person{
        name: "Y4y17",
        age:  20,
        id:   17,
    }
    fmt.Printf("p_struct: %v\n", *p_struct)
    //第二种方式
    var tom person = person{"tom", 20, 17}
    var p_struct1 *person
    p_struct1 = &tom
    fmt.Printf("p_struct1: %v\n", *p_struct1)
    //第三种方式：
    var p_struct2 = new(person)
    p_struct2.age = 22
    p_struct2.name = "Mary"
    fmt.Printf("p_struct2: %v\n", *p_struct2)
}

func main() {
    test2()
}
输出结构如下：
p_struct: {Y4y17 20 17}
p_struct1: {tom 20 17}
p_struct2: {Mary 22 0}

结构体作为函数的参数

package main

import "fmt"

type person struct {
    name string
    age  int
    id   int
}

func show_person(per person) {
    per.name = "Y4y17"
    per.age = 24
    per.id = 17
    fmt.Printf("per: %v\n", per)
}
func main() {
    Mary := person{
        name: "Mary",
        age:  23,
        id:   99,
    }
    fmt.Printf("Mary: %v\n", Mary)
    fmt.Printf("--------------------------\n")
    show_person(Mary)
    fmt.Printf("Mary: %v\n", Mary)
}
Mary: {Mary 23 99}
--------------------------
per: {Y4y17 24 17}
Mary: {Mary 23 99}
package main

import "fmt"

type person struct {
    name string
    age  int
    id   int
}

func show_person(per *person) {
    per.name = "Y4y17"
    per.age = 24
    per.id = 17
    fmt.Printf("per: %v\n", *per)
}
func main() {
    Mary := person{
        name: "Mary",
        age:  23,
        id:   99,
    }
    fmt.Printf("Mary: %v\n", Mary)
    fmt.Printf("--------------------------\n")
    show_person(&Mary)
    fmt.Printf("Mary: %v\n", Mary)
}
修改一下代码，使得变成传递地址的方式：
Mary: {Mary 23 99}
--------------------------
per: {Y4y17 24 17}
Mary: {Y4y17 24 17}

结构体的嵌套

package main

import "fmt"

type person struct {
    name string
    age  int
    id   int
    cat  cat	//结构体中嵌套着一个cat结构体
}

type cat struct {
    name  string
    age   int
    color string
}

func main() {
    cat := cat{
        name:  "敢敢",
        age:   1,
        color: "grey",
    }
    Y4y17 := person{
        name: "Y4y17",
        age:  23,
        id:   17,
        cat:  cat,
    }
    fmt.Printf("Y4y17: %v\n", Y4y17)
    fmt.Printf("Y4y17.cat.name: %v\n", Y4y17.cat.name)
}
Y4y17: {Y4y17 23 17 {敢敢 1 grey}}
Y4y17.cat.name: 敢敢

Go语言中的方法

go语言没有面向对象的特性，也没有类对象的概念。但是，可以使用结构体来模拟这些特性，我们都知道面向;象里面有类方法等概念。我们也可以声明一些方法，属于某个结构体。

Go语言方法的语法

Go中的方法，是一种特殊的函数，定义于struct之上(与struct关联、绑定)，被称为struct的接受者(receiver)。通俗的讲，方法就是有接收者的函数。

语法格式如下：
type mytype struct{}
func (recv mytype) my_method( para) return_type {}
func (recv *mytype) my_method(para) return_type {}
mytype :定义一个结构体
recv∶接受该方法的结构体(receiver)my_method:方法名称
para :参数列表
return_type :返回值类型

从语法格式可以看出，一个方法和一个函数非常相似，多了一个接受类型。

package main

import "fmt"

type person struct {
	name string
}

func (per person) eat() {
	fmt.Printf("%v eating...\n", per.name)
}
func (per person) sleep() {
	fmt.Printf("%v sleeping...\n", per.name)
}
func main() {
	var tom person
	tom.name = "tom"
	tom.eat()
	tom.sleep()
}
package main

import "fmt"

type customer struct {
    name string
}

func (cus customer) login(name string, pwd string) bool {
    if name == "tom" && pwd == "123" {
        return true
    } else {
        return false
    }
}
func main() {
    cus := customer{
        name: "tom",
    }
    b := cus.login("tom", "123")
    fmt.Printf("b: %v\n", b)
}

Go语言方法的注意事项

  1. 方法的receiver type并非一定要是struct类型，type定义的类型别名、slice、map、channel、func类型等都可以。

  1. struct结合它的方法就等价于面向对象中的类。只不过struct可以和它的方法分开，并非一定要属于同一个文件，但必须属于同一个包。

  1. 方法有两种接收类型: (T Type)和(T *Type)，它们之间有区别。

  1. 方法就是函数，所以Go中没有方法重载(overload)的说法，也就是说同一个类型中的所有方法名必须都唯一。如果receiver是一个指针类型，则会自动解除引用。

  1. 方法和type是分开的，意味着实例的行为(behavior)和数据存储(field)是分开的，但是它们通过receiver建立起关联关系。

Go语言方法接收者类型

分为值类型和指针类型

package main

import "fmt"

type customer struct {
    name string
}

//传值
func (cus customer) test1() {
    cus.name = "Y4y17"
}

//传递指针
func (cus *customer) test2() {
    cus.name = "Y4y17"
}
func main() {
    cus := customer{
        name: "tom",
    }
    cus.test1()
    fmt.Printf("cus: %v\n", cus)	//cus: {tom}
    cus.test2()
    fmt.Printf("cus: %v\n", cus)	//cus: {Y4y17}

}

Y4y17
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Day3 Golang学习笔记
weixin_51920241的博客
05-03 165
今日学习部分 1. 常见的四种变量声明方式与多变量声明方式 2. const与iota知识点注意事项 3. Golang中函数的多返回值的三种写法 4. import导包路径问题与init方法调用流程 总结 知道了变量的声明方式以及其简洁的声明方法，还有Goland里节省内存的表现： var a int fmt.Println("a = ", a) 声明了变量a，后面就必须得用到a，不然声明变量的那行代码中，a处就会划红线，提示错误为Unused variable ‘a’ 声明全局变量，方法一、二、
golang学习笔记（十）
凌云天空的博客
07-16 134
go语言提供了一种数据类型叫做接口（interface）。就是定义了一组方法或者或者说函数。可以看做对象的一组行为。既然对象难免有数据，我们可以通过struct定义对象类型，然后根据struct实现这一组方法。 这样就实现了多态，不同对象调用相同接口方法，实现不同功能。这样的好处是将定义与实现分离，降低了耦合性。 这个跟C语言中我们定义一个结构体，里面定义一组函数指针，通过实现定义的函数指针赋值给结构体对象，形成一个模块，有异曲同工之妙。 struct...
Golang学习 Day_09
qq_52423136的博客
03-10 93
Golang学习 Day_09 map,面向“对象”编程，结构体，方法 “如果你无力去做那种惊天动地的大事，那就满怀热情地做好眼前的小事”
Golang学习 Day_11
qq_52423136的博客
03-12 96
Golang学习Day_11
日常学习总结golang(day3)---结构体
lili9415的博客
03-26 129
1.递归 递归：函数自己调用自己，适合处理那种问题相同、问题规模越来越小的场景。 注意：递归一定要有一个明确的退出条件，否则很容易成死循环。 计算n的阶乘 func f(n uint64) uint64 { if n<=1{ return 1 } return n*f(n-1) } func main() { ret:=f(5) fmt.Println(ret)//1...
Golang学习笔记
技术宇宙
01-05 1753
目录特点天然并发函数可以返回多个值开发目录结构Golang 执行流程分析参考 特点 Go 语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率动态语言开发维护的高效率 使用一个表达式来形容 Go 语言：Go = C + Python 说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发 天然并发 从语言层面支持并发，实现简单 goroutine，轻量级线程，可实现大并发处理，高效利用多核 基于 CSP 并发模型(Communicating S
日常学习总结golang(day5)---文件操作
lili9415的博客
03-28 169
文件操作 文件是什么？ 计算机中的文件是存储再外部介质(通常是磁盘)上的数据集合，文件分为文本文件和二进制文件。 1. 打开和关闭文件 os.Open()函数能够打开一个文件，返回一个*File和一个err。对得到的文件实例调用close()方法能够关闭文件。 func main() { //只读的方式打开当前目录下的demo.go file,err:=os.Open("./demo.go")...
日常学习总结golang(day1)---数组、切片、指针
lili9415的博客
03-24 236
对于go语言的语法还是简单易懂的，不过还是要多看看，加深一下印象。而只学基本语法是根本无法满足开发的需求的。最近跟着视频学习，除了基本语法还有并发、中间件、日志库、互联网协议、Mysql、redis、gin、docker等等。为了以后自己复习方便，看完后进行一些总结。有需要的同学也可以看一下！ 1. for…range(键值循环) Go语言中可以使用for...range遍历数组、切片、字符串、...
golang zap日志模块封装sentry
dorlolo的博客
08-30 241
错误消息会展示错误类型，其它的debug、info等会直接展示消息名称。
如何完美实现 Go 服务的平滑升级
禅与代码的艺术
08-27 1410
首先通过一个具体的实验，演示了 Go 服务升级是如何引起的请求 502,从而引起平滑升级的必要性。其次，介绍了 Go 语言原生的信号处理框架，为后续讲解平滑升级打下基础。最后，讲解了如何实现 Go 服务的平滑退出以及开源框架 gracehttp。
如何使用 Go 语言开发微服务
禅与代码的艺术
08-27 1000
首先以 Go 语言原生的 RPC 标准库为例，介绍了如何实现客户端程序与服务端程序。最后，介绍了字节跳动开源的微服务框架 Kitex 的基本使用方式，还重点介绍了其在可扩展性方面以及服务治理方面的实现原理。
Golang | Leetcode Golang题解之第377题组合总和IV
weixin_66442839的博客
08-27 587
Golang | Leetcode Golang题解之第377题组合总和IV
初识 Go 语言，环境配置有问题
沐爸的博客
08-26 1013
Go 语言以其简洁的语法、强大的标准库和高效的并发模型而广受欢迎。初识Go，分享一下环境搭建，遇到了一些问题。
Golang | Leetcode Golang题解之第383题赎金信
weixin_66442839的博客
08-30 356
Golang | Leetcode Golang题解之第383题赎金信
Golang安装与环境配置
夏月歌者的博客
08-26 463
适用于新手的Windows上安装Go开发环境，以及一些必要的配置
第一个go程序
zhourongxiang1的博客
08-28 250
hello.go所在目录。
Golang 字面量的表示
最新发布
Dablelv 的博客专栏。
08-30 489
在 Go 语言中，字面量是用来表示固定值的表达式。Go 支持几种类型的字面量，包括整型、浮点型、字符串、字符、布尔值以及复合类型（如数组、切片、结构体、映射等）。下面我将介绍一些在 Go 语言中使用字面量的常见技巧和最佳实践。
leecode 31.下一个排列（Golang）
wuye_lh的博客
08-30 185
leecode 31.下一个排列，golang解决
golang 学习路线
06-10
3. 学习 golang 的并发编程，因为 golang 在并发编程方面有很多优化，可以提高程序的性能。 4. 学习 golang 的 Web 编程，掌握 gin、beego 等常用 Web 框架，了解如何使用 golang 进行 Web 开发。 5. 学习 golang ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Y4y17

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值