Question

只是一个简单的问题。我有以下代码，它可以正常工作：

class obA: Printable {
    var description: String { get { return "obA" } }
}

class obB: Printable {
    var description: String { get { return "obB" } }
}


func giveObject() -> obA { return obA() }
func giveObject() -> obB { return obB() }

var a: obA = giveObject()
var b: obB = giveObject()

println(a)
println(b)

正在调用giveObject的正确变体，一切都很好。当然这只是一个简化的案例，实际上在我的项目中有几十个'giveObject'的重载，所有的返回类型都不同。现在，我想制作一个通用函数来解析所有这些东西。那么，下一步：

func giveGeneric<T>() -> T {
    return giveObject()
}

var c: obA = giveGeneric()
println(c)

这引起了对giveObject的模糊使用的抱怨。我可以理解错误的来源，但我不知道如何解决它并使用这样的结构......

Answer 1

即使您为任何可能的类型实现giveObject函数，这也无法工作。由于T可以是任何类型，因此giveGeneric方法无法确定要调用的正确重载。

我能想到的唯一方法是创建一个巨大的swift，其中包含你想要处理的类型数量的案例：

func giveGeneric<T>() -> T? {
    switch "\(T.self)" {
    case "\(obA.self)":
        return giveObject() as obA as? T
    case "\(obB.self)":
        return giveObject() as obB as? T
    default:
        return .None
    }
}

但我认为即使拿着枪指向我的头部也不会使用这样的解决方案 - 这真的很难看。

如果在所有情况下使用无参数构造函数创建实例，那么您可以创建协议并约束T泛型类型来实现它：

protocol Instantiable {
    init()
}

func giveGeneric<T: Instantiable>() -> T {
    return T()
}

您可以使用内置和新类型 - 例如：

extension String : Instantiable {
    // `String` already implements `init()`, so nothing to add here
}

let s: String = giveGeneric()

或者，如果您愿意，可以使协议声明为静态giveObject方法而不是无参数构造函数：

protocol Instantiable {
    static func giveObject() -> Self
}

func giveGeneric<T: Instantiable>() -> T {
    return T.giveObject()
}

extension String : Instantiable {
    static func giveObject() -> String {
        return String()
    }
}

let s: String = giveGeneric()

Answer 2

首先只是一张纸条。

如果giveGeneric的泛型类型只是T，那么它可以是任何东西（String，Int，...）。那么giveObject()在这种情况下应该如何反应？

我的意思是，如果你写：

let word : String = giveGeneric()

在你的泛型函数内部调用类似的东西：

let result : String = giveObject() // Ambiguous use of giveObject

我的解决方案

我宣布了一个协议如下：

protocol MyObject {
    init()
}

然后我让你的2个类符合协议

class obA: Printable, MyObject {
    var description: String { get { return "obA" } }
    required init() {}
}

class obB: Printable, MyObject {
    var description: String { get { return "obB" } }
    required init() {}
}

最后我可以写这个

func giveGeneric<T:MyObject>() -> T {
    return T()
}

现在我可以使用它了：

let a1 : obA = giveGeneric()
let b1 : obB = giveGeneric()

您可以决定这是您正在寻找的解决方案，还是仅仅是一种解决方法。

具有返回类型重载的Swift泛型函数调用函数

2 个答案:

我的解决方案