Golang - 复合类型

最新推荐文章于 2024-10-27 17:57:36 发布
最新推荐文章于 2024-10-27 17:57:36 发布
阅读量110 收藏
点赞数
文章标签： golang 数据结构与算法
原文链接：http://www.cnblogs.com/konghui/p/10703595.html
版权

目录

Golang - 复合类型

1. 指针

  • go语言中指针是很容易学习的，比C中容易的多，它可以更简单地执行一些任务
  • 与变量类似，使用前需要声明，使用&符号可以取内存地址
  • 声明指针的格式：
    • var 指针变量名 *指针类型

指针的使用

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
    //声明变量
    var a int = 20

    //声明指针变量
    var p *int
    p = &a

    //十六进制
    fmt.Printf("a变量的地址是: %x\n", &a)
    fmt.Printf("p变量存储的指针地址: %x\n", p)

    //使用指针访问值
    fmt.Printf("*p变量的值: %d\n", *p)
}


//a变量的地址是: c042052080
//p变量存储的指针地址: c042052080
//*p变量的值: 20

通过指针修改变量

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
    //定义变量
    var num int = 10
    fmt.Println(&num)
    var ptr *int

    //指针赋值
    ptr = &num
    //通过指针修改num
    * ptr = 20
    fmt.Println(num)
}

//0xc042052080
//20

go空指针

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
    var ptr *int
    fmt.Println("ptr的值为:", ptr)

    //判断空指针
    if ptr == nil{
        fmt.Println("是空")
    }
}

//ptr的值为: <nil>
//是空

值传递和引用传递

void pass_by_val(int a){
a++;
}

void pass_by_ref(int& a){
a++;
}

int main() {
int a = 3;

pass_by_val(a);
printf("pass_by_val: %d\n", a)
printf("pass_by_ref: %d\n", a)
}

答案：3，4

值传递:

//package 声明开头表示代码所属包
package main

import "fmt"

func swap(a, b int){
    a, b = b, a
}

func main() {
    a, b := 3, 4
    swap(a, b)
    fmt.Println(a, b)
}

// 3  4

go引用传递:

//package 声明开头表示代码所属包
package main

import "fmt"

func swap(a, b *int){
    *a, *b = *b, *a
}

func main() {
    a, b := 3, 4
    swap(&a, &b)
    fmt.Println(a, b)
}

// 4  3

2. new()和make()

  • new()用来分配内存，但与其他语言中的同名函数不同，它不会初始化内存，只会将内存置零
  • make(T)会返回一个指针，该指针指向新分配的，类型为T的零值，适用于创建结构体

  • make()的目的不同于new()，它只能创建slice、map、channel，并返回类型为T（非指针）的已初始化（非零值）的值

    //package 声明开头表示代码所属包
package main

import "fmt"

func main() {
    p :=new([]int)
    fmt.Println(p)

    //[]int切片
    //10: 初始化10个长度
    //50: 容量为50
    m :=make([]int, 10, 50)
    fmt.Println(m)

    m[0] = 10
    (*p)[0] = 10
    fmt.Println(p)
}

3. 数组

声明变量:

var 数组名[数组长度] 数组类型

声明和初始化数组:

//package 声明开头表示代码所属包
package main

import "fmt"


func main() {
    //数组长度不让变化
    //定义int类型数组
    var arr1 [5]int

    //:=声明并赋值
    arr2 := [3]int{1, 2, 3}

    //可以省略大小
    arr3 := [10]int{2, 4, 6, 8, 10}
    fmt.Println(arr1, arr2, arr3)

    //定义二维数组
    var grid [4][5]int
    fmt.Println(grid)
}

//[0 0 0 0 0] [1 2 3] [2 4 6 8 10 0 0 0 0 0]
//[[0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]

数组是值类型还是引用类型?

package main

import "fmt"

//传入数组，修改元素
func printArr(arr [5]int)  {
   //修改一个元素
   arr[0] = 100
   for i,v := range arr{
      fmt.Println(i,v)
   }
}

func main() {
   //定义数组
   var arr1 [5]int

//:=声明并赋值
   arr2 := [3]int{1, 2, 3}
   //可以省略大小
   arr3 := [...]int{2, 4, 6, 8, 10}
   fmt.Println(arr1, arr2, arr3)

   //printArr(arr1)
   //报错
   //printArr(arr2)
   printArr(arr3)

   //打印原始值
   fmt.Println()
   fmt.Println(arr3)
}

4. slice

  • 数组的长度在定义之后无法再次修改，go语言提供了数组切片（slice）来弥补数组的不足

  • 创建切片的各种方式

      //package 声明开头表示代码所属包
  package main

  import "fmt"

  func main() {
      //声明空切片
      var s1 []int

      //:=声明
      s2 :=[]int{}

      var s3 []int = make([]int, 0)
      s4 :=make([]int, 0, 0)
      fmt.Println(s1, s2, s3, s4)
  }


  [] [] [] []

.

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
    //定义数组
    arr :=[...]int{0, 1, 2, 3, 4, 5, 6, 7}

    //切片取值
    fmt.Println(arr[2:6])
    fmt.Println(arr[:6])
    fmt.Println(arr[2:])
    fmt.Println(arr[:])
}


//[2 3 4 5]
//[0 1 2 3 4 5]
//[2 3 4 5 6 7]
//[0 1 2 3 4 5 6 7]

go切片可以向后扩展, 但不能向前扩展

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
    //定义数组
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := arr[2:6]
    fmt.Println(s1)
    s2 := s1[3:5]
    fmt.Println(s2)
    
    //切片添加元素
    s3 := append(s2,10)
    fmt.Println(s3)
    fmt.Println(arr)

    s4 := append(s3,11)
    fmt.Println(s4)
    fmt.Println(arr)
    s5:= append(s4,12)
    fmt.Println(s5)
    fmt.Println(arr)
}

//[2 3 4 5]
//[5 6]
//[5 6 10]
//[0 1 2 3 4 5 6 10]
//[5 6 10 11]
//[0 1 2 3 4 5 6 10]
//[5 6 10 11 12]
//[0 1 2 3 4 5 6 10]

内建函数copy()

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
    //切片
    data := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    s1 := data[8:]
    s2 := data[:5]
    fmt.Println(s1)
    fmt.Println(s2)

    //将第二个拷贝到第一个里
    copy(s2, s1)
    fmt.Println(s2)
    fmt.Println(data)
}

//[8 9]
//[0 1 2 3 4]
//[8 9 2 3 4]
//[8 9 2 3 4 5 6 7 8 9]

5. Map

  • Map 是go内置的数据结构，是一种无序的键值对的集合，可以通过key快速找到value的值
  • 定义Map：
    • var 变量名 map[key的数据类型] value的数据类型

    • 创建map

          //package 声明开头表示代码所属包
    package main

    import "fmt"

    func main() {
        //声明map
        var mmp map[int]string
        fmt.Println(mmp == nil)

        //m2和m3是等价的
        m2 := map[int]string{}
        m3 :=make(map[int]string)
        fmt.Println(m2, m3)

        m4 :=make(map[int]string, 10)
        fmt.Println(m4)
    }

    //true
    //map[] map[]
    //map[]

初始化map

//package 声明开头表示代码所属包
package main

import "fmt"

func main() {
    //1. 定义同时初始化
    var m1 map[int]string = map[int]string{1:"超哥", 2:"最帅"}
    fmt.Println(m1)

    //2. 自动推导类型 :=
    m2 :=map[int]string{1:"超哥", 2:"最帅"}
    fmt.Println(m2)
}

//map[1:超哥 2:最帅]
//map[1:超哥 2:最帅]

键值操作

//package 声明开头表示代码所属包
package main

func main() {
    m1 :=map[int]string{1:"111",2:"222"}
    
    //修改
    m1[1]="1111"
    //追加
    m1[3]="333"
}

6. 结构体

  • go语言没有class，只是个结构体struct
  • 结构体定义：
    • type 结构体名 struct{}
  • 结构体初始化

//package 声明开头表示代码所属包
package main

import "fmt"

//定义学生结构体
type Student struct {
    id int
    name string
    sex byte
    age int
    addr string
}

func main() {
    //1.顺序初始化
    var s1 Student = Student{1,"约汉",'f',18,"bj"}
    fmt.Println(s1)
    s2 := Student{2,"接客",'m',20,"sh"}
    fmt.Println(s2)
    //s3 := Student{3,"撸死",'m',25}

    //2.指定初始化成员
    s4 := Student{id:4,age:26}
    fmt.Println(s4)
    fmt.Println(s4.id)

    //3.结构体作为指针变量初始化
    var s5 *Student = &Student{5,"接客",'f',20,"sh"}
    fmt.Println(s5)
    //指针类型访问变量
    //go底层自己实现了转换，下面2种都可以取指针对象的属性
    fmt.Println((*s5).id)
    fmt.Println(s5.id)

    s6 := &Student{6,"接客",'m',20,"sh"}
    fmt.Println(s6)
}

//{1 约汉 102 18 bj}
//{2 接客 109 20 sh}
//{4  0 26 }
//4
//&{5 接客 102 20 sh}
//5
//5
//&{6 接客 109 20 sh}

7. 结构体参数

结构体可以作为函数参数传递

//package 声明开头表示代码所属包
package main

import "fmt"

type Student struct {
    id   int
    name string
    sex  string
    age  int
    addr string
}

//定义传递学生对象的方法
func tmpStudent(tmp Student) {
    //修改id
    tmp.id = 250
    fmt.Println("tmp=", tmp)
}

//定义传递指针类型的对象的方法
func tmpStudent2(p *Student) {
    //修改id
    p.id = 249
    fmt.Println("tmp2=", p)
}

func main() {
    var s Student = Student{1, "接客", "female", 20, "sz"}
    tmpStudent(s)
    fmt.Println("main s =", s)
    //传递指针地址
    tmpStudent2(&s)
    fmt.Println("main s2=", s)
}

//tmp= {250 接客 female 20 sz}
//main s = {1 接客 female 20 sz}
//tmp2= &{249 接客 female 20 sz}
//main s2= {249 接客 female 20 sz}

转载于:https://www.cnblogs.com/konghui/p/10703595.html

anzhehan1535
关注
桫哥-GOlang-03复合类型
06-12
在本课程"桫哥-GOlang-03复合类型"中，我们将深入探讨Go语言的复合类型，这是学习任何编程语言的重要组成部分。Go语言，也称为Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的、C风格的...
golang的复合类型
weixin_54323180的博客
06-30 540
golang的复合数据类型：数组、slice、map、结构体。数组和结构体是聚合类型。它们的值由内存中的一组变量构成。数组元素具有相同的类型，而结构体可以不同。数组和结构体的长度都是固定的。slice和map是动态数据结构。 数组 在这里插入代码片 ...
golang复合数据类型【数组】
J_Lee
01-28 507
顾名思义，复合数据类型就是由其他类型组合而成的类型。Go语言基本的复合数据类型有：指针、数组、切片、字典（map）、通道、结构和接口 一、数组（Array） 1.1 什么是数组？ Go语言提供了数组类型的数据结构。 数组是具有相同唯一类型的一组编号且长度固定的数据项序列，这种类型可以是任意的原始类型，例如：整形、字符串或者自定义类型。 数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引为1，以此类推，数组的下标取值范围是从0开始，到长度减1。 1.2 数组的特点
golang 中的复合类型
qq_55272229的博客
06-06 590
前言 所有的api文档都可以使用bash命令 go doc 查看文档的帮助信息从 Go 1.13 开始，godoc 不再随 Go 发行版一起安装，你需要单独安装它。需要单独安装2执行命令 godoc -http=:1111 打开浏览器 http://localhost:1111/pkg/ 即可查看文档。
Golang的复合数据类型
qq_34365039的博客
05-04 369
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 Golang的复合数据类型前言一、Pointer二、Struct三、ArraySlicemakeappend总结 前言 提示：这里可以添加本文要记录的大概内容： Golang中除了int之类的基础数据类型，还有指针，结构体和数组之类的复合数据类型。 本篇文章来学习一下Golang的复合数据类型 提示：以下是本篇文章正文内容，下面案例可供参考 一、Pointer 和C一样，Golang也有指针，用法和C也相似 如： var p *i.
Golang复合类型
wallace_www的博客
03-10 1万+
前言 上文 Golang 基本类型 中我们介绍了golang 基本类型的常见用法，本文将介绍 golang 中的复合数据类型，常用的复合数据类型有 array 数组，slice 切片，map 字典 和 struct 四种。 数组 数组是一个由固定长度的特定类型元素组成的序列，由于长度固定，在实际业务场景下使用较为不便，因此在 go 中很少直接使用。 数组的长度是数组类型的一个组成部分，因此 [3]int 和 [4]int 是两种不同的数组类型。数组的长度必须是常量表达式，因为数组的长度需要在编译阶段确定。
golang-base
01-23
Go语言提供了整型（`int`、`uint`）、浮点型（`float32`、`float64`）、字符串（`string`）、布尔型（`bool`）等基本类型，以及指针（`*T`）、数组（`[n]T`）、切片（`[]T`）和映射（`map[K]V`）等复合类型。...
Golang-常见面试题目解析.rar
03-19
- **数据类型**：包括基本类型（如int、float、bool、string）和复合类型（如数组、切片、结构体）。 - **控制流**：涉及if语句、switch语句、for循环、while模拟等。 - **函数**：理解函数的定义、参数传递、...
golang-program
03-07
- **类型系统**：Go支持多种数据类型，包括基本类型（如int、float、bool、string），复合类型（如数组、切片、结构体），以及接口类型。 - **变量声明**：使用`var`关键字声明变量，可以同时初始化。Go语言还支持...
golang-common-func
05-12
Go语言支持基本类型如int、float、bool和string，以及复合类型如数组、切片、映射（map）、结构体（struct）。变量声明使用`var`关键字，常量使用`const`。Go还引入了类型推断，使得可以省略变量的类型，通过赋值来...
Golang学习笔记（2）-复合类型
ZHen_G_RuI的博客
06-07 282
Golang学习，复合类型
Go语言——复合类型
脑袋装水的博客
07-24 745
1. 数组 a.【声明数组】 var name [size] type // 如果数组长度不确定，可以使用 ... 代替数组的长度， // 编译器会根据元素个数自行推断数组的长度： balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0} b.【初始化数组】 name := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0} // 1. 方式一:完整写法 var arr [3]int = [3]int{1, 2, 3} // 2
golang中的复合数据类型
ens160的博客
09-08 266
了解数据结构一般会从数组开始，因为数组是切片和映射的基础数据结构，理解了额数组的工作原理，有助于理解切片和映射提供的优雅，强大的功能。 数组是具有相同类型的一组已经编号且长度固定的数据项序列，这个序列可以是有序的也可以是无序的，组成数组的各个变量常为数组的元素。这种类型可以是任意的原始类型int，string，自定义类型。数组长度必须是一个非负整数的常量，或常量表达式，数组长度也是数组类型的一部分， 数组的声明需要指定元素的数据类型，以及存储元素的数量， var array [5] int 数组一单.
golang复合类型总结
github_zwl的博客
04-17 346
golang复合类型总结 指针类型，数组，切片，map和结构体 指针： 指针就是地址 var p *int a=1 p = &a *p = 999 相当于a=999 指针必须有一个合法的指向才能调用赋值等 new关键字和make关键字留意一下。new之后不需要释放，自动的gc 值传递和指针传递的区别---值传递是拷贝一份，指针则是指向其内存 ...
Golang 函数多参数重构为复合类型
muyouking
10-10 1502
如果一个函数参数过多，可以重构为一个复合结构类型，如下 package main import ( "fmt" "log" "time" ) /* 如果一个函数参数过多，可以重构为一个复合结构类型，如下*/ type serverOptino struct { address string port int path string timeout time.D...
Golang从入门到精通（十三）：Golang复合数据之map
热门推荐
xiangxianghehe的博客
12-13 1万+
map概念Go 语言中 map 是一种特殊的数据结构：一种元素对（pair）的无序集合，pair 的一个元素是key，对应的另一个元素是value，所以这个结构也称为关联数组或字典。这是一种快速寻找值的理想结构：给定key，对应的value可以迅速定位。map 这种数据结构在其他编程语言中也称为字典（Python）、hash 和HashTable 等。map声明和初始化map 是引用类型，可以使用如
Go语言中的复合类型及面向对象思想
思月行云
08-22 2203
1、结构体 struct 定义格式： type 结构体名称 struct { 属性1 类型 属性2 类型 ... } 结构体的初始化可以使用new关键词和var关键词，不同的是如果使用new，则返回类型是一个指针，使用var，则是结构体自身。 type User struct { name string age int }
纯GO语言开发RTSP流媒体服务器-RTSP推流直播、本地保存录像、录像回放、http-flv及hls协议分发
最新发布
GoFLy开发者的博客
10-27 1125
使用GO语言开发RTSP直播服务器，不依赖任何第三方GO语言框架，使用原生GO语言撸。并把把RTSP服务器做成插件方便安装使用，有开发文档方便二次开发，除了在GoFly快速开发框架使用外，我们可以把插件简单改造就可以加入到其他Go开发框架，也可以独立开发成存RTSP功能服务器。
golang基本数据类型
07-27
引用\[2\]进一步解释了Golang的基本类型、复合类型、引用类型和接口类型。基本类型包括数字、字符串和布尔型。复合类型包括数组和结构体，用于表示更复杂的数据结构。引用类型包括指针、切片、映射、通道、接口和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值