Swift Benutzerdefinierte Variablentyp

Question

Für mit komplexen Zahlen arbeiten, das ist, wie ich habe es getan:

import Foundation 

class Complex { 
    var real: Float 
    var imaginary: Float 
    init(re: Float, im: Float) { 
     self.imaginary = im 
     self.real = re 
    } 
    func abs() -> Float { 
     return sqrtf(powf(self.real, 2) + powf(self.imaginary, 2)) 
    } 

    func string() -> String { 
     if (ceilf(self.real) == self.real) && (ceilf(self.imaginary) == self.imaginary){ 
      return "\(Int(self.real))+\(Int(self.imaginary))i" 
     } 
      return "\(self.real)+\(self.imaginary)i" 
    } 

    func arg() -> Float { 
      return atan2f(self.imaginary, self.real) 
    } 
} 

var someComplex = Complex(re: 2, im: 3) 
var someComplexString = someComplex.string() //"2+3i" 
var someComplexAbsolute = someComplex.abs() // 3.60... 
var someComplexArgument = someComplex.arg() //0.98... 

Nun ich habe mich gefragt, ob es eine Möglichkeit war eine benutzerdefinierte Variablentyp zu definieren, lassen würde ich schreibe es zum Beispiel als someComplex: Complex = 3i. Ist es möglich, einen neuen Typ "von Grund auf" zu erstellen?

Answer 1

können Sie verwenden ein typealias:

typealias Name = String 

Jetzt können Sie Name verwenden, wenn Sie sonst String verwenden:

func sayHello(to name: Name) { 
    print("Hello " + name) 
} 

Answer 2

Ich bin etwas unsicher, ob dies ist, was Sie suchen , aber basierend auf Ihrem Kommentar zu der anderen Antwort

„Danke, aber was bedeuten, dass ich war so etwas wie ein benutzerdefinierter Typ, der alle Schwimmer und ich zum Beispiel annehmen würde“,

Sie einen Wrapper erstellen könntest, die einen einzelnen generischen Wert gilt, wobei den generischen Typen dieses Wertes ist Typ eingeschränkt zu einem Protokoll, zu dem Sie wiederum die Typen erweitern, die Sie Wrappable aber den Typ sein möchten. ZB unter Typen ermöglicht Int, Float und String zu der Sie

protocol MyGenericTypes { } 

extension Int: MyGenericTypes { } 
extension Float: MyGenericTypes { } 
extension String: MyGenericTypes { } 

struct SomeWrapper<T: MyGenericTypes> { 
    var value: T 
    init(_ value: T) { 
     self.value = value 
    } 
} 

let myInt = 42 
let myFloat: Float = 4.2 
let myString = "forty-two" 

let wrappedInt = SomeWrapper(myInt)  // T inferred as "Int" 
let wrappedFloat = SomeWrapper(myFloat) // T inferred as "Float" 
let wrappedString = SomeWrapper(myString) // T ingerred as "String" 

print(wrappedInt.dynamicType) // SomeWrapper<Int> 
print(wrappedFloat.dynamicType) // SomeWrapper<Float> 
print(wrappedString.dynamicType) // SomeWrapper<String> 

Umhüllung eingehüllt werden können generische Funktionen natürlich schreiben damit Argumente für SomeWrapper<T> Fälle Typ T in der gleichen Weise wie in der Struktur Definition oben

Zwang

func foo<T: MyGenericTypes>(bar: SomeWrapper<T>) ->() { 
    print(bar.value) 
} 

foo(wrappedInt) // 4.2 
foo(wrappedFloat) // 42 
foo(wrappedString) // forty-two