Golang 使用介面實現泛型
在C/C++中我們可以使用泛型的方法使程式碼得以重複使用,最常見例如stl functions:vector<int> vint
orvector<float> vfloat
等。這篇文章將使用interface{...}介面使Golang實現泛型。
interface{...}是實現泛型的基礎。如一個數組元素型別是interface{...}的話,那麼實現了該介面的實體都可以被放置入陣列中。注意其中並不一定必須是空介面(簡單型別我們可以通過把他轉化為自定義型別後實現介面)。為什麼interface中要宣告方法:因為當我們需要對陣列內資料進行操作時(如比較大小),我們需要為這個操作宣告一個自定義的方法。換言之,只有實現了這個方法的實體才允許被加入進陣列中。
基礎Demo
在下面演示的Demo中,我們將實現一個最簡單的vector,並實現插入時排序的功能。
type Comper interface{ Lessthan (Comper) bool } type Sdata struct{ data []Comper } func (t *Sdata) Push (item Comper){ t.data = append(t.data, item) for k,v:=range t.data{ if item.Lessthan(v) {//呼叫介面定義的方法 //排序操作 break } } }
如此便實現了一個最簡單的Demo,使用Sdata的陣列元素必須先實現Lessthan方法:
type Myint int func (t Myint) Lessthan (x Comper) bool { return t<x.(Myint) } func main() { mydata := Sdata{make([]Comper, 0)} for i:=10;i>0;i--{ mydata.Push((Myint(i))) } fmt.Println(mydata) }
但這個Demo的缺點也有許多,一是簡單型別元素無法使用Sdata進行排序,二是不支援併發,在併發的情況下會產生不可預料的結果。
通過Reflect支援簡單型別的Demo
為要支援簡單型別,我們只能使用空介面作為陣列元素型別。這時候我們的程式邏輯應該是這樣:如果這是一個簡單型別,那麼我們直接呼叫內建的"<"與">"進行比較;如果這不是一個簡單型別,那麼我們仍舊呼叫Lessthan方法:
type Comper interface{ Lessthan (Comper) bool } type Sdata struct{ data []interface{} } func (t *Sdata) Push (item interface{}){ for _,v:=range t.data{ if reflect.TypeOf(item).Implements(reflect.TypeOf(new(Comper)).Elem()) { citem:=item.(Comper) cv:=v.(Comper) if citem.Lessthan(cv) { //要執行的操作 break } }else{ x,v:=reflect.ValueOf(item),reflect.ValueOf(v) switch x.Kind() { case reflect.Int: case reflect.Int8: case reflect.Int16: /*...*/ //x, y:=x.Int(), y.Int() /*...*/ break case reflect.Uint: /*...*/ } } } }
reflect.TypeOf(item).Implements(reflect.TypeOf(new(comper)).Elem())
,即item型別是否實現了comper介面型別。TypeOf(new(comper))
是一個指標ptr,Elem()
將指標轉為值。如果該函式返回值為true,則可將item和v從interface{}強制轉為Comper介面,呼叫Lessthan(...);當然你也可以使用型別斷言,那種方式更簡單也更常用,我在這兒只是嘗試一下使用反射的方法:if v,ok:=item.(comper); ok{...}
不能直接對value型別進行大小比較:value型別不能通過">"與"<"直接比較大小,即使我們知道他是簡單型別。作者還沒有找到簡單的方法能直接轉化值為簡單型別並比較,因此採用了列舉的方法。若有更簡便的方法,也請告知。
如果使用例項指標實現介面:這是一個比較難以發現的問題,涉及到golang的型別系統。也就是說,如果我們實現Lessthen的方法是這樣func (t
*
Myint) Lessthan (x Comper) bool
,那麼很有可能你的斷言item型別就要失敗了。我們可以看一下此時item的型別:
fmt.Println(reflect.TypeOf(t.data[0]))//main.XXX
這不是我們期待的,因為我們知道只有*T
型別的方法集才是S和*S
,而T
型別的方法集只有S
。很明顯,main.XXX的方法集裡不包括Lessthan方法,只有*main.XXX
才包括。所以正確的使用方法是,在最初賦值的時候就賦值給指標型別:
mi := Myint(i) mydata.Push(&mi)
多介面分層Demo
空介面其實只是一個特殊用例,我們將其推廣後即可發現,我們可以定義多個介面,宣告多種方法,實體實現了若干種方法便有許可權呼叫若干函式:
例如我們可以賦予讀取許可權,寫入許可權與刪除許可權,來對應不同需求:
type Reader interface { Read () interface{} } type Writer interface { Write (Writer) } type ReadWriter interface { Reader Writer } type Remover interface { Remove () } type Sdata struct { data []interface{} } func (t *Sdata)Get(i int)interface{}{ if len(t.data) == 0{return nil} if reflect.TypeOf(t.data[0]).Implements(reflect.TypeOf(new(Reader)).Elem()) == true{ return t.data[i].(Reader).Read() } } func (t *Sdata)Modify(i int, w Writer){ // if reflect.TypeOf(t.data[0]).Implements(reflect.TypeOf(new(ReadWriter)).Elem()) == true if _,ok:=t.data[0].(ReadWriter);ok{ t.data[i].(Writer).Write(w) } } //......
自定義Myint型別並實現Reader,Writer介面:
type Readint int func (t Readint) Read() interface{}{ return int(t) } //--------------------------------------------- type Myint int func (t Myint) Read() interface{}{ return int(t) } func (t *Myint) Write(w Writer){ *t = *w.(*Myint) return } func main() { mydata := Sdata{make([]interface{}, 1)} var u,v Myint = 5,6 mydata.data[0] = &u fmt.Println("Myint is ", mydata.Get(0)) mydata.Modify(0,&v) fmt.Println("Myint is ", mydata.Get(0)) var ru Readint = 100 readdata := Sdata{make([]interface{}, 1)} readdata.data[0] = &ru fmt.Println("Readint is ", readdata.Get(0)) //var rv Readint = 101 readdata.Modify(0,&v)//事實上,如果傳遞rv則編譯根本不會通過。 fmt.Println("Readint is ", readdata.Get(0)) }
執行結果:
Myint is5 Myint is6 Readint is100 Readint is100
說明:如果因為認為上述程式碼傳遞&rv
根本不會通過編譯而不去作型別檢查,這是不可取的。因為對於空介面interface{}而言,無所謂實體的型別,只在乎是否實現方法,因此傳遞&v
是合情合理的。另外,因為該Demo是一個簡易版本,所以判斷許可權部分僅僅根據判斷第0個元素的許可權。事實上,判斷許可權應該在初始化時完成並將其儲存在結構體變數中。
最後關於併發的問題,套用讀寫鎖即可。過於簡單不再通過Demo驗證。