Question

对于处理复杂的数字，我就是这样做的：

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...

现在我想知道，如果有任何方法可以定义一个自定义类型的变量，让我把它写成someComplex: Complex = 3i例如。是否可以从头开始创建新类型＆＃34;？

Answer 1

我有点不确定这是否是您正在寻找的，但根据您对其他答案的评论

“谢谢，但我的意思是类似于接受所有花车的自定义类型，例如”，

您可以创建一个包含单个通用值的包装器，其中此值的泛型类型类型约束到某个协议，然后您可以扩展您希望可以包装的类型但是类型。例如，下面允许包装器包装类型Int，Float和String

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>

您可以自然地编写允许SomeWrapper<T>个实例的参数的泛型函数，以与上面结构定义相同的方式键入T

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

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

Swift自定义变量类型

1 个答案: