Go语言学习(五)---指针、类型定义、结构体、方法、接口

最新推荐文章于 2024-04-17 12:16:53 发布
最新推荐文章于 2024-04-17 12:16:53 发布
阅读量489 收藏
点赞数
分类专栏： Go语言学习 文章标签： golang 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56540305/article/details/133974271
版权

目录

一、golang指针

1.1指针语法

1.2golang指针数组

二、golang类型定义和类型别名

2.1golang类型定义和类型别名的区别

三、结构体

3.1结构体的定义

匿名结构体

直接定义一个结构体类型的变量

3.2结构体的初始化

3.3结构体指针

3.4golang结构体作为函数参数

3.5golang中结构体的嵌套

四、golang方法

4.1语法

4.2 go语言方法的注意事项

​编辑4.3golang方法接收者类型

五、golang接口

5.1接口的语法格式

 5.2golang接口 值类型和指针类型

5.3 golang接口和类型的关系

一个类型实现多个接口

多个类型实现一个接口  

5.4 golang接口嵌套

5.5 golang通过接口实现OCP设计原则

5.6 golang中模拟OOP(面向对象)中的属性和方法

5.7golang继承

5.8 golang构造函数

一、golang指针

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

Go中的指针不能进行偏移和运算

1.1指针语法

一个指针变量指向了一个值的内存地址(也就是说我们声明了一个指针之后，可以像变量赋值一样，把一个值的内存地址放入到指针中)

var var_name *var_name

package main

import (
	"fmt"
)

func main() {
	var ip *int
	fmt.Printf("ip:%v\n", ip) //ip:<nil> 指针在没有赋值时是nil
	fmt.Printf("ip:%T\n", ip) //ip:*int

	//赋值
	var i int =100
	ip=&i
	fmt.Printf("ip:%v\n", ip) //ip:0xc00000a110 可以看到i内存地址
	fmt.Printf("ip:%v\n", *ip) //ip:100 可以看到ip指针中存放的内存地址对应的内容

	var sp *string
	var s string = "hello"
	sp=&s
	fmt.Printf("sp:%T\n", sp) //sp:*string
	fmt.Printf("sp:%v\n", sp) //sp:0xc000024070
	fmt.Printf("sp:%v\n", *sp) //sp:hello

}

1.2golang指针数组

定义语法 表示数组里面的元素的类型是指针类型

var ptr [MAX]*int

package main

import (
	"fmt"
)
/*
golang指向数组的指针
*/
func main() {
	a:=[3]int{1,2,3}
	var pa [3]*int
	fmt.Printf("pa:%v\n", pa) //pa:[<nil> <nil> <nil>]
	for i := 0; i < len(a); i++ {
		pa[i]=&a[i] //把a中每个元素的地址取出来赋值给pa
	}
	fmt.Printf("pa:%v\n", pa) //pa:[0xc00000e0f0 0xc00000e0f8 0xc00000e100]
	for i := 0; i < len(pa); i++ {
		fmt.Printf("pa:%v ", *pa[i]) //pa:1pa:2pa:3
	}
}

二、golang类型定义和类型别名

2.1golang类型定义和类型别名的区别

2.2类型定义

type NewType Type

2.3类型别名

type NewType = Type

 示例

package main

import (
	"fmt"
)
/*
golang类型定义和类型别名
*/
func main() {
	//类型定义
	type MyInt int
	var i MyInt
	i=100
	fmt.Printf("i:%T\n",i) //i:main.MyInt i的类型是MyINt不再是int
	fmt.Printf("i:%v\n",i) //i:100

	//类型别名
	type MyInt1 = int
	var j MyInt1
	j=100
	fmt.Printf("j:%T\n",j) //j:int
	fmt.Printf("j:%v\n",j) //100
}

三、结构体

3.1结构体的定义

package main

import (
	"fmt"
)
/*
golang结构体
*/
//定义
type Person struct{
	id int
	name string
	age int
}
func main() {
	//声明一个结构体变量
	var tom Person
	fmt.Printf("tom:%v\n", tom) //tom:{0  0} 没有初始化时，每个成员都是最初的值
	tom.id=10
	tom.age=20
	tom.name="tom"
	fmt.Printf("tom:%v\n", tom) //tom:{10 tom 20}
	// kite:=Person()
	// fmt.Printf("kite:%v\n", kite)
}

匿名结构体

直接定义一个结构体类型的变量

package main

import (
	"fmt"
)
/*
golang结构体
*/
//定义
// type Person struct{
// 	id int
// 	name string
// 	age int
// }
func main() {
	var dog struct{
		id int
		name string
	}
	dog.id=1
	dog.name="zxx"
}

3.2结构体的初始化

package main

import (
	"fmt"
)
/*
golang结构体初始化
*/
//定义
type Person struct{
	id int
	name string
	age int
}
func main() {
	var tom Person
	//方法一：使用键值的形式初始化 也可以部分初始化
	tom = Person{
		id:101,
		name:"tom",
		age:20,
	}
	fmt.Printf("%v", tom) //{101 tom 20}
	//方法二：通过顺序的方法初始化
	var amy Person
	amy = Person{
		102,
		"amy",
		19,
	}
	fmt.Printf("%v", amy) //{102 amy 19}
	//方法三：通过直接赋值的方式初始化
	var kite Person
	kite.id=103
	kite.name="kite"
	kite.age=21
	fmt.Printf("%v", kite)//{103 kite 21}
}

3.3结构体指针

package main

import (
	"fmt"
)
/*
golang结构体指针
*/
//定义
type Person struct{
	id int
	name string
	age int
}
func main() {
	var tom Person
	tom = Person{
		id:101,
		name:"tom",
		age:20,
	}
	var p_person *Person //定义一个结构体类型的指针，指针名称为p_person
	p_person=&tom
	fmt.Printf("%v", tom) //{101 tom 20}
	fmt.Printf("%v", p_person) //&{101 tom 20}
	fmt.Printf("%p", p_person) //0xc0000603a0  占位符是p表明输出指针类型，输出地址
	fmt.Printf("%v", *p_person) //{101 tom 20}

	//使用new创建一个结构体指针
	var amy=new(Person)
	fmt.Printf("%p", amy) //0xc000060440 指针类型
	(*amy).id=101 //理论上的写法，但是这里*可以忽略，就变成下面这种常见写法
	amy.age=23 
	amy.name="amy"
	fmt.Printf("%v", *amy) //{101 amy 23} 注意打印输出时要加星号
	
}

3.4golang结构体作为函数参数

package main

import (
	"fmt"
)
/*
golang结构体作为函数参数
*/
//定义
type Person struct{
	id int
	name string
}
//值传递，拷贝了一份副本
func showPerson(per Person){
	per.id=101
	per.name="amy"
	fmt.Printf("last:%v\n", per) 
}
func showPerson2(per *Person){
	per.id=102
	per.name="anna"
	fmt.Printf("last:%v\n", per) 
}
func main() {
	var tom Person
	tom = Person{
		id:101,
		name:"tom",
	}
	showPerson(tom)//last:{101 amy}
	fmt.Println("----------")
	fmt.Printf("%v\n", tom) //{101 tom}
	var per *Person
	per=&tom
	showPerson2(per)
	fmt.Printf("%v\n", tom) //{102 anna} tom被修改了
	
}

3.5golang中结构体的嵌套

golang没有面向对象编程思想，也没有继承关系，但是可以通过结构体嵌套来实现这种效果

package main

import (
	"fmt"
)
/*
golang结构体嵌套
*/
//定义
type Dog struct{
	name string
	color string
	age int
}
//Person中嵌套了Dog
type Person struct{
	dog Dog
	id int
	name string
}

func main() {
	var tom Person
	fmt.Printf("tom:%v", tom) //tom:{{  0} 0 }
	dog:=Dog{
		"xiaohuang",
			"huang",
			11,
	}
	tom=Person{
		dog,
		101,
		"tom",
	}
	fmt.Printf("tom:%v", tom) //tom:{{xiaohuang huang 11} 101 tom}
}

四、golang方法

go语言中的方法是一种特殊的函数，被称为struc的接收者。

方法就是有接受者的函数

4.1语法

package main

import (
	"fmt"
)
/*
golang方法
*/
//定义
//Person中嵌套了Dog
type Person struct{
	name string
}
type Customer struct{
	name string
}
//属性和方法分开来写

//person 接收者receiver
func (person Person) eat(){
	fmt.Printf("%v,eat....\n", person.name)
}
func (person Person) sleep(){
	fmt.Printf("%v,sleep..\n", person.name)
}
func (cus Customer) login(name string,pwd string) bool{
	fmt.Printf("cus.name:%v\n", cus.name)
	if name==cus.name&&pwd=="123"{
		return true
	}else{
		return false
	}
}

func main() {
	per:=Person{
		"tom",
	}
	per.eat() //不能直接使用eat(),必须要有一个接收者。即per.eat()
	per.sleep()

	cus:=Customer{
		"zxx",
	}
	flag1:=cus.login("zxx","123")
	fmt.Printf("%v", flag1)
}

4.2 go语言方法的注意事项

4.3golang方法接收者类型

结构体实例有指针类型和值类型，那么方法的接收者是结构体，也有值类型和指针类型。区别就是接收者是否复制结构体副本。值类型复制但是指针类型不复制

package main

import (
	"fmt"
)
/*
golang方法
*/
//定义
//Person中嵌套了Dog
type Person struct{
	name string
}
func f1(){
	per1:=Person{
		"tom",
	}
	per2:=&Person{
		name:"tom",
	}
	fmt.Printf("per1:%T", per1) //main.Person
	fmt.Printf("per2:%T", per2) //*main.Person
}

func (per Person)showPerson1(){
	per.name="tom..."
}
func (per *Person)showPerson2(){
	//per.name  ----  自动解引用
	per.name="tom..."
}
func main() {
	p1:=Person{
		name:"tom",
	}
	p2:=&Person{
		name:"tom",
	}
	p1.showPerson1()
	fmt.Printf("p1:%v\n", p1)//p1:{tom}
	fmt.Printf("p2:%v\n", p2)//p2:&{tom}
	p2.showPerson2() //接收者是指针类型，就不会复制结构体副本，会修改本结构体
	fmt.Printf("p1:%v\n", p1)//p1:{tom}
	fmt.Printf("p2:%v\n", p2)//p2:&{tom...}

	
}

五、golang接口

接口像是一个公司里面的领导，会定义一些通用规范。只设计规范，而不实现规范

go语言的接口，是一种新的类型定义，它把所有的具有共性的方法定义在一起。任何其他类型只要实现了这些方法就是实现了这个接口

5.1接口的语法格式

示例

package main

import (
	"fmt"
)
/*
golang接口
*/
//个人理解：接口中包含着有共性的方法，比如电脑和手机都有USB接口
//对于USBer里面的方法，电脑和手机都可以实现
type USBer interface{
	read()
	write()
}
type Computer struct{
	name string
}
type Mobile struct{
	model string
}
func (c Computer) read(){
	fmt.Printf("c.name:%v\n", c.name)
	fmt.Println("read...")
}
func (c Computer) write(){
	fmt.Printf("c.name:%v\n", c.name)
	fmt.Println("write...")
}

// func (m Mobile) read(){
// 	fmt.Printf("m.name:%v\n", m.model)
// 	fmt.Println("read...")
// }
func (m Mobile) write(){
	fmt.Printf("m.name:%v\n", m.model)
	fmt.Println("write...")
}

func main() {
	c:=Computer{
		name:"my_computer",
	}
	c.read()
	c.write()

	m:=Mobile{
		model:"5G",
	}
	// m.read()
	m.write()
}

理解一下，接口本身没有直接性的功能，而是起到一个规范的作用

比如之前我们写过一些代码，我们想要调用之前的方法来实现一个功能，就需要单

独去找这些方法的位置，而接口就是将某个功能所需的所有方法放在一起，作为一个规范

其他人看到了接口内的方法名就知道要去找那些方法来实现功能了
————————————————
版权声明：本文为CSDN博主「默子昂」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_42883074/article/details/123114736

 5.2golang接口 值类型和指针类型

package main

import (
	"fmt"
)
/*
golang接口值类型接收者和指针类型接收者
*/
type Pet interface{
	eat(string) string
	eat1(string) string
}

type Dog struct {
	name string
}
func (dog Dog) eat(name string) string{
	dog.name="huahua..."
	fmt.Printf("%v\n", name)
	return "吃的很好"
}
func (dog *Dog) eat1(name string) string{
	dog.name="huahua..."
	fmt.Printf("%v\n", name)
	return "吃的很好"
}
func main() {
	dog:=Dog{
		name:"huahua",
	}
	dog1:=&Dog{
		name:"huahua",
	}
	s:=dog.eat("huoji")
	s1:=dog1.eat1("huoji")
	fmt.Printf("s:%v\n", s)
	fmt.Printf("s1:%v\n", s1)
	fmt.Printf("dog:%v\n", dog)
	fmt.Printf("dog1:%v\n", *dog1) //dog1:{huahua...} 修改过了
}

5.3 golang接口和类型的关系

  1. 一个类型可以实现多个接口
  2. 多个类型可以实现同一个接口(多态)

一个类型实现多个接口

package main

import (
	"fmt"
)
/*
golang接口和类型的关系
*/
type Player interface {
	playMusic()
}
type Video interface {
	PlayVedio()
}
type Mobile struct {
	
}
func (m Mobile) playMusic(){
	fmt.Println("play music")
}
func (m Mobile) playVideo(){
	fmt.Println("play video")
}

func main() {
	//一个类型(Mobile)实现多个接口(Player、 Video)
	m:=Mobile{}
	m.playMusic()
	m.playVideo()
}

多个类型实现一个接口  

Comuputer和Mobile都实现了USBer接口

package main

import (
	"fmt"
)
/*
golang接口
*/
//个人理解：接口中包含着有共性的方法，比如电脑和手机都有USB接口
//对于USBer里面的方法，电脑和手机都可以实现
type USBer interface{
	read()
	write()
}
type Computer struct{
	name string
}
type Mobile struct{
	model string
}
func (c Computer) read(){
	fmt.Printf("c.name:%v\n", c.name)
	fmt.Println("read...")
}
func (c Computer) write(){
	fmt.Printf("c.name:%v\n", c.name)
	fmt.Println("write...")
}

func (m Mobile) read(){
	fmt.Printf("m.name:%v\n", m.model)
	fmt.Println("read...")
}
func (m Mobile) write(){
	fmt.Printf("m.name:%v\n", m.model)
	fmt.Println("write...")
}

func main() {
	c:=Computer{
		name:"my_computer",
	}
	c.read()
	c.write()

	m:=Mobile{
		model:"5G",
	}
	m.read()
	m.write()

	//真正意义上实现接口
	var usb USBer
	usb=Computer{
		name:"my_computer",
	} 
	usb.read()//c.name:my_computer read...
	usb=Mobile{
		model:"5G",
	}  
	//如果mobile中的read或者write方法没有全部实现的话，
	//说明没有成功继承这个接口
	//则usb=Mobile{}会报错
	usb.read() //m.name:5G read...

}

5.4 golang接口嵌套

接口可以通过嵌套，创建新的接口。例如：飞鱼，既可以飞，又可以游泳。我们创建一个fly接口，再创建一个游泳接口swim。飞鱼由这两个接口组成

package main

import (
	"fmt"
)
/*
golang接口嵌套
*/
type Fly interface {
	fly()
}
type Swim interface {
	swim()
}
type FlySwim interface {
	Fly
	Swim
}
func (fish Fish) fly(){
	fmt.Println("fly")
}
func (fish Fish) swim(){
	fmt.Println("swim")
}
type Fish struct {
}



func main() {
	var ff FlySwim
	ff=Fish{}
	ff.fly() //fly
	ff.swim() //swim
}

5.5 golang通过接口实现OCP设计原则

面向对象的可复用设计的第一块基石，就是所谓的”开闭“原则(open-closed Principle,缩写为OCP)。虽然go不是面向对象语言，但是也可以模拟实现这个原则

开闭原则：对扩展是开放的，对修改是关闭的

示例：主任现在有两只宠物：猫和狗，他们都实现pet接口，完成吃和睡的工作。对于主任来说，只需要care(宠物)j即可，如果主人还有别的宠物，例如小猪，就可以另小猪实现pet接口，从而调用care(pig)，只需要添加，不需要修改。如此就反映出了OCP原则，即对于扩展开放，对于修改关闭

package main

import (
	"fmt"
)
/*
golang OCP设计原则
*/

type Pet interface {
	eat()
	sleep()
}

type Dog struct {
}

type Cat struct {
}
//dog实现接口方法
func (dog Dog)eat(){
	fmt.Println("dog eat...")
}
func (dog Dog)sleep(){
	fmt.Println("dog sleep...")
}
//cat实现接口
func (cat Cat)eat(){
	fmt.Println("cat eat...")
}
func (cat Cat)sleep(){
	fmt.Println("cat sleep...")
}
type Person struct {
	
}

//pet既可以是cat也可使dog--向上类型转换
func (person Person) care(pet Pet){
	pet.eat()
	pet.sleep()
}


func main() {
	dog:=Dog{}
	cat:=Cat{}
	person:=Person{}
	person.care(dog) //dog eat... dog sleep...因为传递的是dog，所以向上类型转换成了dog
	person.care(cat) //cat eat... cat sleep... 因为传递的是cat，所以向上类型转换成了cat
	/*
	如果主人还有别的宠物，例如小猪，就可以另小猪实现pet接口，从而调用care(pig).
	如此就反映出了OCP原则，即对于扩展开放，对于修改关闭
	*/
}

5.6 golang中模拟OOP(面向对象)中的属性和方法

可以通过结构体和函数绑定来实现，即加一个接收者receiver-----方法

package main

import (
	"fmt"
)
/*
golang 模拟OOP
*/

type Person struct {
	name string
	age int
}
func (per Person) eat(){
	fmt.Println("eat...")
}
func (per Person) sleep(){
	fmt.Println("sleep...")
}
func (per Person) work(){
	fmt.Println("work...")
}

func main() {
	per:=Person{
		name:"tom",
		age:11,
	}
	per.eat() //eat...
	per.sleep() //sleep...
	per.work() //work...

	
}

5.7golang继承

因为golang没有oop的概念，所以也没有继承的概念。但是可以通过结构体嵌套来实现

package main

import (
	"fmt"
)
/*
golang 继承
*/
type Animal struct {
	name string
	age int
}
func (a Animal)eat()  {
	fmt.Println("eat...")
}
func (a Animal)sleep()  {
	fmt.Println("sleep")
}

type Dog struct {
	a Animal  //可以理解为dog继承了animal
	color string
}

type Cat struct {
	a Animal  //可以理解为cat继承了animal
	color string
}
/*
cat和dog可以通过结构体嵌套这种方式
继承Animal中的属性(name,age)和方法(sleep,eat)
*/

func main() {
	//方式一：
	// dog:=Dog{
	// 	a:Animal{name:"huahua",age:2},
	// 	color:"yellow",
	// }
	// cat:=Cat{
	// 	a:Animal{name:"quanquan",age:3},
	// 	color:"blue",
	// }
	// dog.a.eat()
	// dog.a.sleep()
	// cat.a.eat()
	// cat.a.sleep()

	//方式二
	dog:=Dog{
		Animal{name:"huahua",age:2},
		"yellow",
	}
	cat:=Cat{
		Animal{name:"quanquan",age:3},
		"blue",
	}
	dog.a.eat()
	dog.a.sleep()
	cat.a.eat()
	cat.a.sleep()
	
}

5.8 golang构造函数

golang没有构造函数的概念，可以使用函数来模拟构造函数的功能

package main

import (
	"fmt"
)
/*
golang 构造函数
*/
type Person struct {
	name string
	age int
}

func NewPerson(name string,age int)(*Person,error){
	if name==""{
		return nil,fmt.Errorf("name 不能为空")
	}
	if age<0{
		return nil,fmt.Errorf("age 不能小于0")
	}
	return &Person{name:name,age:age},nil
}
func main() {
	per,err:=NewPerson("tom",11)
	if err==nil{
		fmt.Printf("per:%v\n", per) //per:&{tom 11}
	}else{
		fmt.Printf("err:%v\n", err)
	}

}

一啊鸭0402
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Go 学习笔记（13）— 指针定义、指针特点、空指针、指针数组、指向指针的指针、指针作为函数入参
wohu1104的专栏
08-24 2333
1. 指针定义 Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。 获取变量在内存中地址： package main import "fmt" func main() { var a int = 10 fmt.Printf("变量的地址: %x\n", &a ) } 输出结果： 变量的地址: 20818a220 一个指针变量指向了...
go深度学习
12-10
本节为go机器学习与深度学习，主要讲解go在机器学习和深度学习方面的应用，如图像识别等。
Go-结构体类型详解（声明、初始化、结构体指针、方法、序列化等
最新发布
2301_77110907的博客
04-17 513
构造函数使用工厂模式，根据属性来进行对象的创建。选中首字母小写的属性，右键点击Generate或快捷键Alt+Insert。3)对于方法，形参为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以，内部属性是否改变取决于形参。去除了C++等语言的的继承、方法重载、构造函数、析构函数、隐藏的this指针，很简洁。2)对于普通函数，形参为值类型时，不能将指针类型的数据直接传递，反之亦然。，这与Go一贯的显示转换不同，个人并不喜欢。得到结构体的地址，就是结构体指针。使用{key:value}形式。
Golang关键字--type 类型定义
SHELLCODE_8BIT的博客
02-09 3886
参考Go关键字--type，原文除类型定义外，还介绍了type其它几种使用场合。本文只说类型定义。 type有如下几种用法： 1.定义结构体 2.定义接口 3.类型定义 4.类型别名 5.类型查询 一、类型定义--------节选自《Go语言圣经》第69页 为了说明类型声明，我们将不同温度单位分别定义为不同的类型： // Package tempconv performs Celsius and Fahrenheit temperature computations. package temp
一文了解 Go 中的指针和结构体
cmy_top的博客
11-25 1397
前面的两篇文章对 Go 语言的基础语法和基本数据类型以及几个复合数据类型进行介绍，本文将对 Go 里面的指针和结构体进行介绍，也为后续文章做铺垫。
Go语言中结构体方法副本传参与指针传参的区别介绍
09-20
在Go语言中，结构体方法的定义分为两种：副本传参和指针传参，这两种方式在使用上有着显著的差异。理解这些差异对于编写高效且无误的Go代码至关重要。 首先，我们要知道Go语言中，当我们调用一个方法时，如果接收者...
go学习笔记-文档-文档
07-21
Go语言的接口实现是隐式的，只要类型实现了接口所需的方法，即可被认为实现了该接口。 三、函数与方法 Go语言的函数支持多返回值，这在处理错误或需要返回多个结果时非常有用。同时，Go还引入了闭包和函数作为值的...
Go语言中的方法、接口和嵌入类型详解
01-01
概述 在 Go 语言中，如果一个...一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。 下面定义一个结构体类型和该类型的一个方
Go-autoflags-Go包用于自动从结构体字段自动定义命令行标志
08-14
总的来说，`Go-autoflags`是Go语言中一个非常实用的命令行参数处理库，它通过结构体字段自动化了命令行标志的定义，使得开发命令行工具变得更加便捷。如果你经常编写这类工具，那么`Go-autoflags`无疑是一个值得添加...
go代码-Go 结构体指针
07-14
Go语言中的方法定义必须有一个接收者，这个接收者可以是值类型或者指针类型。如果方法的接收者是结构体指针，那么该方法可以直接修改结构体内容，无需拷贝。例如： ```go func (p *Person) incrementAge() { p....
Golang编程基础: 结构体定义结构体指针类型方法 和 结构体类型方法的区别
听我一言的博客
07-09 1105
type Test struct { integer int pInteger *int } func (t Test) PrintValue() { fmt.Print("Integer[v, addr]: ", t.integer, &t.integer) if nil != t.pInteger { fmt.Println("; PInteger[v, pInteger, addr]: ", *t.pInteger, t.pInteger, &t.pInteger).
1.8 golang基本类型
LvWeijie941的博客
01-30 244
golang的基本类型介绍
go语言神经网络和深度学习
sdadaaagfsee3的博客
08-03 1790
8.神经网络和深度学习 8.1神经网络的术语 节点、感知器或神经元：神经网络的基本组成部分。每个节点或神经元接收输入数据并对数据执行操作。 执行完操作后，该节点或神经元可能会或不会传递操作到下一个节点/神经元 激活：与操作节点相关的输出或者值 激活函数：将节点输入转换成输出或激活操作的函数 权重或偏差：这些值定义了激活函数中输入和输出数据之间的关系 输入层：神经网络的输入层包含一系列节点，用于接收神经网络模型的初始化输入。 输出层：神经网路的输出层包含一些列的节点，用于将信息传递到神经网络内部，并将其转换为
Go中可以为哪些类型定义方法？
u013862108的博客
03-22 533
Go可以为任意类型添加方法。 go 中 都有哪些类型可以 定义方法 ？ struct 肯定可以； 函数 也可以 基本类型 如 int float 等 。。。。还有哪些？ ...
golang中值类型/指针类型的变量区别总结
weixin_30699235的博客
12-11 327
前言 值类型：所有像int、float、bool和string这些类型都属于值类型，使用这些类型的变量直接指向存在内存中的值，值类型的变量的值存储在栈中。当使用等号=将一个变量的值赋给另一个变量时，如 j = i ,实际上是在内存中将 i 的值进行了拷贝。可以通过 &i 获取变量 i 的内存地址 指针类型：简单地说go语言的指针类型和C/C++的指针类型用法是一样的，除了出去安全性的考...
小白学golang-指针类型,值类型,引用类型
Logan_addoil的博客
03-17 674
指针类型 允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。 // 基本数据类型在内存中的布局 var i int = 100 // i 的地址是什么 fmt.Println("i 的地址是 " ,&i) //指针 //ptr 是一个指针变量 类型是 *int 本身的值是 &i(i在内存中的地址) //不能将一个值给指针,指针接收地址 var ptr *int = &i //var ptr *
new 结构体指针_go语言学习结构体(二)
weixin_39636718的博客
12-04 610
go构造函数Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型构造函数当结构体比较大的时候尽量使用结构体指针,减少程序的内存开销,构造函数new开头方法和接收者Go语言中的方法(Method)是一种作用于特定类型变量的函数。这种特定类型...
Go-结构体类型详解（声明、初始化、结构体指针、方法、序列化等）
热门推荐
关注网络安全、云原生安全
04-22 2万+
结构体类型(struct) 去除了继承、方法重载、构造函数、析构函数、隐藏的this指针 type 变量名 struct{ 属性 方法 } 属性 变量 类型 声明 声明并初始化 结构体指针 使用 连续分布 方法 func (reciver type) methodName([parameter list]) ([return list]){ body return value } 方法和函数的区别 1)调用方式不一样 函数的调用方式：函数名...
go语言中指针类型结构体该怎么写
04-01
在Go语言中，定义指针类型结构体的方法与定义普通结构体类似，不同点在于在结构体名前加上"*"表示定义一个指向该结构体的指针类型。 例如，定义一个指向Person结构体的指针类型： ``` type Person struct { name string age int } type PersonPtr *Person // 定义一个指向Person结构体的指针类型 ``` 这样就可以通过PersonPtr类型定义一个指向Person结构体的指针变量，例如： ``` var p PersonPtr p = &Person{"Tom", 20} ``` 在使用指针类型结构体时，可以通过"."操作符来访问结构体的成员，例如： ``` fmt.Println(p.name) // 输出 "Tom" ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值