obsidian-sync/日常学习/golang/泛型.md

泛型是为了解决执行逻辑与类型无关的问题，这类问题不关心给出的类型是什么，只需要完成对应的操作就足够。golang 中的泛型与java概念相似，但是并不完善，定义时需要规定类型范围

定义了一个相加函数，输入必须是int 或者 float32

func Sum[T int | float32](a, b T) T {  
    return a + b  
}

//调用有2种方式
// 1.类型推断
Sum(1, 2)
// 2.指定类型
Sum[int](1, 2)

一、泛型结构

• 切片

//定义
type GenericSlice[T int | string] []T
//使用
GenericSlice[int]{1, 2, 3}

• map

//定义
type GenericMap[K comparable, V int | string | byte] map[K]V
//使用
gmap1 := GenericMap[int, string]{1: "hello world"}
gmap2 := make(GenericMap[string, byte], 0)

• struct

//定义
type GenericStruct[T int | string] struct {
   Name string
   Id   T
}
//使用
GenericStruct[int]{
   Name: "jack",
   Id:   1024,
}
GenericStruct[string]{
   Name: "Mike",
   Id:   "1024",
}

• 泛型切片形参

type Company[T int | string, S int | string] struct {
	Name  string
	Id    T
	Stuff []S
}

Company[int, []int]{
   Name:  "lili",
   Id:    1,
   Stuff: []int{1},
}

• 泛型接口

type SayAble[T int | string] interface {
   Say() T
}

type Person[T int | string] struct {
   msg T
}

func (p Person[T]) Say() T {
   return p.msg
}

func main() {
	//定义SayAble（接口类型），然后初始化为Person，类似java向上造型
	var s SayAble[string]
	s = Person[string]{"hello world"}
	fmt.Println(s.Say())
}

二、类型集

type SignedInt interface {
	int8 | int16 | int | int32 | int64
}

type UnSignedInt interface {
	uint8 | uint16 | uint32 | uint64
}

//并集
type Integer interface {
	SignedInt | UnSignedInt
}

type SignedInt interface {
   int8 | int16 | int | int32 | int64
}

type Integer interface {
   int8 | int16 | int | int32 | int64 | uint8 | uint16 | uint | uint32 | uint64
}

//交集
type Number interface {
	SignedInt
	Int
}

三、数据结构

• 队列

type Queue[T any] []T

func (q *Queue[T]) Push(e T) {
	*q = append(*q, e)
}

func (q *Queue[T]) Pop(e T) (_ T) {
	if q.Size() > 0 {
		res := q.Peek()
		*q = (*q)[1:]
		return res
	}
	return
}

func (q *Queue[T]) Peek() (_ T) {
	if q.Size() > 0 {
		return (*q)[0]
	}
	return
}

func (q *Queue[T]) Size() int {
	return len(*q)
}

• 堆 堆是一种特殊的数据结构，它可以在O(1)的时间内判断最大或最小值，所以它对元素有一个要求，那就是必须是可以排序的类型，但内置的可排序类型只有数字和字符串，并且go的泛型约束不允许存在带方法的接口，所以在堆的初始化时，需要传入一个自定义的比较器，比较器由使用者提供，比较器也必须使用泛型，如下最小堆实现（数组实现最小堆有元素下标公示）

type Comparator[T any] func(a, b T) int

type BinaryHeap[T any] struct {
	//数组容器
	s []T
	//比较器
	c Comparator[T]
}