Ist Allgemeinfunktion und Typ Constraints generische Funktion Polymorphismus in schnellen

Question

Es gibt zwei Funktion unten

func append<T>(_ value: T){ 
...... 
} 

---

func append<T: A>(_ value: T){ 
...... 
} 

, wenn ich sie so nennen sie Polymorphismus durchführen, aber ich kann keine Theorie erhalten Basis von Apple,

let a:A = A() 
append(a) //call func append<T: A> 
let b:B = B() 
append(b) //call func append<T> 

warum append(a) Anruf append<T: A>? Ist Generic Function und Type Constraints generische Funktion Polymorphismus in swift?

Answer 1

Der Effekt, den Sie sehen, ist tatsächlich Funktion Überladung (die auch Ad-hoc-Polymorphismus genannt wird).

Wenn eine Funktion mehrere überladene Versionen hat (in Ihrem Fall eine generische Funktion ohne und eine generische Funktion mit Typ-Constraints), versucht der Compiler immer die Version der Funktion aufzurufen, die für Ihre Eingabeargumente am spezifischsten ist.

Daher wird der Compiler für ein Eingabeargument, das die Typbeschränkung erfüllt, die Funktion mit der Typeinschränkung aufrufen, während für ein Eingabeargument, das die Typeinschränkung nicht erfüllt, die Version ohne Einschränkung aufgerufen wird.

Sie können dieses Verhalten noch besser sehen, wenn Sie eine neue Klasse deklarieren, C, die von A erbt und Sie auch eine überladene Version von append, wo die Typeinschränkung für Klasse C wird erklären. In diesem Fall könnte eine der drei überladenen Versionen für die Klasse aufgerufen werden, aber die spezifischste wird erneut aufgerufen, wobei die Einschränkung für die Klasse C selbst gilt.

class A {} 
class B {} 
class C:A {} 

func append<T>(_ value: T){ 
    print("Most generic version called") 
} 

func append<T: A>(_ value: T){ 
    print("Version with type constraint for class A called") 
} 

func append<T:C>(_ value:T){ 
    print("Version with type constraint for class C called") 
} 

let a:A = A() 
append(a) //calls func append<T: A> 
let b:B = B() 
append(b) //calls func append<T> 
append(C()) //calls func append<T:C> 

Derselbe Effekt kann auch mit überladenen Funktionen erreicht werden, die nicht generisch sind.

func myFunc(_ val: A){ 
    print("Non generic function with input argument of type A called") 
} 

func myFunc(_ val: C){ 
    print("Non generic function with input argument of type C called") 
} 

myFunc(a) //myFunc(_ val: A) called 
myFunc(c) //myFunc(_ val: C) called 

Wenn Sie myFunc(_ val: C) Kommentar aus, myFunc(_ val: A) wird in beiden Fällen genannt werden, da c ein gültiges Eingabeargument für beiden Versionen von myFunc ist.