go语言的"泛型函数or模板函数"

最新推荐文章于 2024-07-25 15:06:16 发布
最新推荐文章于 2024-07-25 15:06:16 发布
阅读量5.2k 收藏
点赞数
分类专栏： golang 文章标签： golang go语言 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/easy_mind/article/details/52884974
版权

首先大家知道golang是没有JAVA的泛型函数或者C++的模板函数这种语法的，今天学到了一种很有用的类似泛型操作的语法，拿来和大家分享

以大家喜闻乐见的Add函数来说明，目的是来实现一个泛型的Add函数

先写了三个ADD函数

package main

import (
	"fmt"
)

func Add1(a, b int) int {
	return a + b
}

func Add2(a, b float32) float32 {
	return a + b
}

func Add3(a, b string) string {
	return a + b
}

func main() {
	a1 := Add1(1, 2)
	a2 := Add2(1.33, 6.82)
	a3 := Add3("hello ", "world")
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3)
}

在把三个ADD函数统一起来前，先学习一个简单的Interface{}的用法，注意int,int32,int64在setvalue的泛型判断中是不同的类型 
package main

import (
	"fmt"
)

func SetValue(ret interface{}) {
	switch data := ret.(type) {
	case *float32:
		*data = 3.14
	case *int:
		*data = 23333
	case *int32:
		*data = 32
	case *int64:
		*data = 64
	default:
		fmt.Println("unknow type")
	}
}

func main() {
	var a1 int
	var a2 int32
	var a3 float32
	var a4 int64
	SetValue(&a1)
	SetValue(&a2)
	SetValue(&a3)
	SetValue(&a4)
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3, "a4 =", a4)
}


相信到这里大部分同学都明白了，我们是要通过switch data:=input.(type)这样的类型判断来实现所谓的泛型，先按照最常规的
伪代码：Add(a,b){return a+b} 来实现 
package main

import (
	"fmt"
)

func main() {
	a1 := Add1(1, 2)
	a2 := Add2(1.33, 6.82)
	a3 := Add3("hello ", "world")
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3)

	b1 := GeneralAdd0(3, 5)
	switch data := b1.(type) {
	case int:
		fmt.Println("b1=", data)
	}
	b2 := GeneralAdd0(1.33, 6.82)
	switch data := b2.(type) {
	case float64:
		fmt.Println("b2=", data)
	}
	b3 := GeneralAdd0("hello ", "add0")
	switch data := b3.(type) {
	case string:
		fmt.Println("b3=", data)
	}
	fmt.Println("b1 =", b1, "b2 =", b2, "b3 =", b3)
}

func Add1(a, b int) int {
	return a + b
}

func Add2(a, b float32) float32 {
	return a + b
}

func Add3(a, b string) string {
	return a + b
}

func GeneralAdd0(a, b interface{}) interface{} {
	switch data := b.(type) {
	case float32:
		switch ta := a.(type) {
		case float32:
			data = data + ta
			return data
		}
	case float64:
		switch ta := a.(type) {
		case float64:
			data = data + ta
			return data
		}
	case int:
		switch ta := a.(type) {
		case int:
			data = data + ta
			return data
		}
	case string:
		switch ta := a.(type) {
		case string:
			data = data + ta
			return data
		}
	default:
		fmt.Println("unknow type")
		return nil
	}

	return nil
}

ps:这里b2其实是个float64类型

也可以传指针 
package main

import (
	"fmt"
)

func main() {
	a1 := Add1(1, 2)
	a2 := Add2(1.33, 6.82)
	a3 := Add3("hello ", "world")
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3)

	b1 := GeneralAdd0(3, 5)
	switch data := b1.(type) {
	case int:
		fmt.Println("b1=", data)
	}
	b2 := GeneralAdd0(1.33, 6.82)
	switch data := b2.(type) {
	case float64:
		fmt.Println("b2=", data)
	}
	b3 := GeneralAdd0("hello ", "add0")
	switch data := b3.(type) {
	case string:
		fmt.Println("b3=", data)
	}
	fmt.Println("b1 =", b1, "b2 =", b2, "b3 =", b3)

	var c1, cret1 int = 10, 42
	GeneralAdd1(&c1, &cret1)
	var c2, cret2 float32 = 5.11, 6.22
	GeneralAdd1(&c2, &cret2)
	var c3, cret3 string = "add1", "I am "
	GeneralAdd1(&c3, &cret3)
	fmt.Println("cret1 =", cret1, "cret2 =", cret2, "cret3 =", cret3)
}

func Add1(a, b int) int {
	return a + b
}

func Add2(a, b float32) float32 {
	return a + b
}

func Add3(a, b string) string {
	return a + b
}

func GeneralAdd0(a, b interface{}) interface{} {
	switch data := b.(type) {
	case float32:
		switch ta := a.(type) {
		case float32:
			data = data + ta
			return data
		}
	case float64:
		switch ta := a.(type) {
		case float64:
			data = data + ta
			return data
		}
	case int:
		switch ta := a.(type) {
		case int:
			data = data + ta
			return data
		}
	case string:
		switch ta := a.(type) {
		case string:
			data = data + ta
			return data
		}
	default:
		fmt.Println("unknow type")
		return nil
	}

	return nil
}

func GeneralAdd1(a, ret interface{}) {
	switch data := ret.(type) {
	case *float32:
		switch ta := a.(type) {
		case *float32:
			*data = *data + *ta
		}
	case *int:
		switch ta := a.(type) {
		case *int:
			*data = *data + *ta
		}
	case *string:
		switch ta := a.(type) {
		case *string:
			*data = *data + *ta
		}
	default:
		fmt.Println("unknow type")
	}
}

看到这里有没有想到一个问题，如果我的add函数是 伪代码：add(a,b,c){return a+b+c}，难道我要switch case嵌套3次？这样的代码看着也太难受了
因此自定义的数据类型也是可以判断的哦 

package main

import (
	"fmt"
)

func main() {
	a1 := Add1(1, 2)
	a2 := Add2(1.33, 6.82)
	a3 := Add3("hello ", "world")
	fmt.Println("a1 =", a1, "a2 =", a2, "a3 =", a3)

	b1 := GeneralAdd0(3, 5)
	switch data := b1.(type) {
	case int:
		fmt.Println("b1=", data)
	}
	b2 := GeneralAdd0(1.33, 6.82)
	switch data := b2.(type) {
	case float64:
		fmt.Println("b2=", data)
	}
	b3 := GeneralAdd0("hello ", "add0")
	switch data := b3.(type) {
	case string:
		fmt.Println("b3=", data)
	}
	fmt.Println("b1 =", b1, "b2 =", b2, "b3 =", b3)

	var c1, cret1 int = 10, 42
	GeneralAdd1(&c1, &cret1)
	var c2, cret2 float32 = 5.11, 6.22
	GeneralAdd1(&c2, &cret2)
	var c3, cret3 string = "add1", "I am "
	GeneralAdd1(&c3, &cret3)
	fmt.Println("cret1 =", cret1, "cret2 =", cret2, "cret3 =", cret3)

	d1 := IntStruct{a: 9, b: 45, ret: 0}
	GeneralAdd2(&d1)
	d2 := Float32Struct{a: 4.77, b: 7.99, ret: 0.0}
	GeneralAdd2(&d2)
	d3 := StringStruct{a: "I am", b: "stringstruct", ret: ""}
	GeneralAdd2(&d3)
	fmt.Println("d1 =", d1.ret, "d2 =", d2.ret, "d3 =", d3.ret)
}

func Add1(a, b int) int {
	return a + b
}

func Add2(a, b float32) float32 {
	return a + b
}

func Add3(a, b string) string {
	return a + b
}

func GeneralAdd0(a, b interface{}) interface{} {
	switch data := b.(type) {
	case float32:
		switch ta := a.(type) {
		case float32:
			data = data + ta
			return data
		}
	case float64:
		switch ta := a.(type) {
		case float64:
			data = data + ta
			return data
		}
	case int:
		switch ta := a.(type) {
		case int:
			data = data + ta
			return data
		}
	case string:
		switch ta := a.(type) {
		case string:
			data = data + ta
			return data
		}
	default:
		fmt.Println("unknow type")
		return nil
	}

	return nil
}

func GeneralAdd1(a, ret interface{}) {
	switch data := ret.(type) {
	case *float32:
		switch ta := a.(type) {
		case *float32:
			*data = *data + *ta
		}
	case *int:
		switch ta := a.(type) {
		case *int:
			*data = *data + *ta
		}
	case *string:
		switch ta := a.(type) {
		case *string:
			*data = *data + *ta
		}
	default:
		fmt.Println("unknow type")
	}
}

type Float32Struct struct {
	a   float32
	b   float32
	ret float32
}

type IntStruct struct {
	a   int
	b   int
	ret int
}

type StringStruct struct {
	a   string
	b   string
	ret string
}

func GeneralAdd2(ret interface{}) {
	switch data := ret.(type) {
	case *Float32Struct:
		data.ret = data.a + data.b
	case *IntStruct:
		data.ret = data.a + data.b
	case *StringStruct:
		data.ret = data.a + data.b
	default:
		fmt.Println("unknow type")
	}
}
通过自定义IntStruct, Float32Struct, StringStruct这结构体来实现，这样的代码看着就舒服多了

easy_mind
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang泛型介绍
uxff的专栏
01-11 5484
go开发团队与2021.12.15将泛型发布在go1.18beta1版本中。本文将介绍如何在golang中使用泛型，以及golang泛型与其他语言(c++,java,c#)比较。golang泛型正式发布将于2022年2月的1.18版本与大家见面。
R语言泛型函数
04-12
在日常数据处理中，我们可能会有这样的情况：即使看了函数的帮助文档， 仍然不能很好的使用这个函数。或者我们仅仅是对这个函数如何实现这样的复杂 功能感到好奇。...本文档包含了查看泛型函数源代码的方法
go语言基础之泛型
liu289747235的专栏
01-28 1848
当我们编写的是操作 Go 语言定义的特殊容器类型（slice、map和chennel）的函数。如果函数具有包含这些类型的参数，并且函数的代码并不关心元素的类型，那么使用类型参数可能是有用的。例如：返回任何类型map中所有的key// MapKeys 返回m中所有key组成的切片return s。
Go泛型详解
清风的博客
07-11 1164
官网文档：https://go.dev/blog/intro-generics。
golang泛型
热门推荐
weixin_44961320的博客
06-15 1万+
1.18go泛型
golang 泛型编程
冷月醉雪的博客
02-23 1059
    众所周知，Golang中不支持类似C++/Java中的标记式泛型，所以对于常用算法，比如冒泡排序算法，有些同学容易写出逻辑上重复的代码，即整型是第一套代码，字符串型是第二套代码，用户自定义类型是第三套代码。     重复是万恶之源，我们当然不能容忍，所以要消除重复，使得代码保持在最佳的状态。本文通过一个实际使用的简单算法的演进过程，初次体验了Golang的泛型编程，消除了重复代码，非常自...
golang学习：泛型
huangfengnt的博客
09-04 1474
go泛型
Golang 泛型详解
最新发布
07-25 1058
/ 自定义一个新类型 MapTT：类型形参。定义 MapT 时 T 代表的类型并不确定，类似一个占位符。：类型约束。指定 T 仅可接受哪些类型。中括号内定义形参类型，称为形参类型列表。其中，类型约束可以包上 interface{}m[T] = valreturn m// 或简写为type T interface{int|int32|float32|string} // 自定义类型约束。
不同Java泛型构造函数的详解
08-25
Java泛型构造函数详解 Java中泛型构造函数是一种特殊的构造函数，它至少需要有一个泛型类型参数。泛型构造函数可以出现在泛型类中，也可以出现在非泛型类中。在本文中，我们将讨论不同的Java泛型构造函数，包括非...
.net泛型通用函数的特殊问题的解决方法
10-27
.NET 泛型通用函数在提供灵活性的同时，也会遇到一些特殊问题，主要体现在无法直接使用运算符重载。本文将深入探讨这个问题以及相应的解决方法。 在.NET框架中，泛型（Generic）自2.0版本引入以来，极大地提升了...
Java泛型构造函数（学习资料）
06-17
Java 泛型构造函数是Java编程中用于增强类型安全性的工具，它们允许我们在类的构造函数中使用类型参数。在创建对象时，泛型构造函数能够确保传入的数据类型符合预定义的约束，从而减少类型转换错误并提高代码的...
Python中泛型函数应用案例.pdf
06-29
Python中的泛型函数是一类可以接收不同数据类型参数的函数，并且可以适应不同类型的操作，它们提供一种方式来编写与数据类型无关的代码。Python本身不直接支持泛型类型，但可以通过一些设计模式来模拟泛型行为。文档...
golang中使用泛型
猛犸象
04-21 7129
泛型支持 go >= 1.18 为什么需要泛型 编写一个函数用来比较两个数的大小，对于golang这种强类型的语言，要么针对不同的类型分别实现一遍，要么使用 interface{} 类型。 func CompareInt64(a, b int64) bool { if a >= b { return true } else { return false } } func CompareFloat64(a, b float64) bool { if a >= b { r
Golang 1.x版本泛型编程
weixin_34026276的博客
04-23 291
Go是一门天生为服务器程序设计的简洁的语言，因此Go的设计原则聚焦在可扩展性、可读性和并发性，而多态性并不是这门语言的设计初衷，因此就被放在了一边。虽然在2.0版本之前还没有泛型的支持，但是Go自带的一些语言特性可以满足一些类似“泛型”的要求，比如内置类型：arrayslicemapchan这四种类型可以用任意类型的元素初始化，例如map[yourtype]bool就可以用来实现任意元素的集合。G...
【Go】泛型
陈戏猿
12-09 2217
Go1.17引入了泛型的特性，1.18正式开放泛型，本文介绍了Go语言泛型的基本语法，使用示例，以及简要的实现原理，帮助你了解Go的泛型。
为什么 Go 语言没有泛型 · Why's THE Design?
Go中国
02-01 1306
为什么这么设计（Why’s THE Design）是一系列关于计算机领域中程序设计决策的文章，我们在这个系列的每一篇文章中都会提出一个具体的问题并从不同的角度讨论这种设计的优缺点、对具体...
Golang泛型
bai1112的博客
02-01 827
golang泛型
全面解读！Golang中泛型的使用
QcloudCommunity的博客
06-21 7049
导语|Golang在2022-03-15发布了V1.18正式版，里面包含了对泛型的支持，那么最新版本的泛型如何使用呢？有哪些坑呢？本文全面且详细的带你了解泛型在Golang中的使用。一、什么是泛型说起泛型这个词，可能有些人比较陌生，特别是PHP或者JavaScript这类弱语言的开发者，尤其陌生。因为在这些弱语言中，语法本身就是支持不同类型的变量调用的。可以说无形之中...
GO - 泛型编程
qq_45887694的博客
04-07 2063
类型参数列表使用方括号括起来，并在其中声明一个或多个类型参数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值