Pergi: Bagaimana untuk menentukan jenis kekangan di mana jenis hujah kaedah adalah sama dengan jenis penerima

Dalam bahasa Go, kita boleh menggunakan kekangan jenis untuk menentukan jenis parameter fungsi atau kaedah. Bagaimanakah kita menentukan apabila kita mahu jenis parameter kaedah sama dengan jenis penerima? Pertama sekali, perlu jelas bahawa bahasa Go tidak secara langsung menyokong ciri bahawa jenis parameter adalah sama dengan jenis penerima. Walau bagaimanapun, kita boleh mencapai kesan yang sama dengan menggunakan jenis penunjuk dalam definisi kaedah. Seterusnya, kami akan memperincikan cara untuk menentukan jenis parameter untuk sama dengan jenis penerima dalam bahasa Go.

Kandungan soalan

Saya ingin menentukan jenis kekangan seperti yang ditunjukkan di bawah:

type Comparer interface {
    Compare(another Comparer) int
}

Tetapi saya mahu jenis pelaksanaan menghantar jenis konkritnya sendiri kepada kaedah Compare 而不是接口 Comparer 中，如下所示（我知道以下没有实现 Comparer):

func (a MyInt) Compare(b MyInt) int {
    xxxx
    return xxxx
}

Saya cuba menggunakan antara muka generik seperti ini:

type Comparer[T any] interface {
    Compare(T) int
}

Tetapi ini tidak memaksa penerima kaedah Compare juga daripada jenis T.

Adakah terdapat cara untuk memaksa jenis penerima dan jenis parameter kaedah Compare menjadi sama?

Penyelesaian

Apabila anda bercakap tentang kekangan, anda pada asasnya merujuk kepada penggunaan khusus jenis antara muka sebagai sekatan pada set parameter jenis.

Jadi apabila anda (betul) mentakrifkan antara muka sebagai:

type Comparer[T any] interface {
    Compare(T) int
}

Anda hanya bercerita separuh sahaja. Sebenarnya, perkara di atas bukanlah satu batasan. Ia hanya antara muka.

Untuk benar-benar menjadi kekangan jenis, antara muka mesti digunakan sebagai satu.

func Foo[T Comparer[T]](t1, t2 T) int {
    return t1.Compare(t2)
}

type Thing[T Comparer[T]] struct {
    Value T
}

Hanya dalam senarai parameter jenis, anda boleh menguatkuasakan Compare(T) 的接收者为 T sendiri dengan mewujudkan kekangan dengan parameter jenisnya.

Apabila tidak digunakan sebagai kekangan, antara muka hanyalah definisi satu set kaedah, mengikut reka bentuk tanpa sebarang sekatan pada jenis yang boleh melaksanakannya.

Anda kini boleh menggunakan istilah jenis untuk menentukan jenis yang mesti melaksanakan antara muka tertentu. Tetapi parameter jenis tidak boleh digunakan secara langsung sebagai istilah jenis. Anda perlu menggunakan jenis yang tidak dinamakan, seperti penunjuk ke T:

type Comparer[T any] interface {
    *T
    Compare(T) int
}

Perhatikan bahawa ini memaksa anda untuk mengisytiharkan kaedah pada penerima penunjuk, cth. *MyInt, yang mungkin sesuai atau tidak.

Walau bagaimanapun, ini tidak boleh dijadikan instantiated sebagai T Comparer[T] dengan parameter jenisnya sendiri kerana kekangan akan mengenakan tahap tambahan arah penunjuk tanpa mengira apa itu T Comparer[T] 因为无论 T. Parameter fungsi tidak pernah memuaskannya.

Cara untuk mencapai kefungsian ini adalah untuk menjadikannya instant Comparer dengan parameter jenis yang berbeza.

func test[T any, V Comparer[T]](a, b T) int {
    return V(&a).Compare(b)
}

dan isytiharkan kaedahnya sebagai:

type MyInt int

func (t *MyInt) Compare(other MyInt) int {
    // implementation
}

Walaupun jika anda menggunakan kekangan antara muka seperti yang dimaksudkan, penyelesaian yang rumit ini menjadi tidak diperlukan sama sekali.

Taman permainanhttps://www.php.cn/link/3ea816621e0d8ecd5e534ec28051d4d5

Atas ialah kandungan terperinci Pergi: Bagaimana untuk menentukan jenis kekangan di mana jenis hujah kaedah adalah sama dengan jenis penerima. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!