&引用；通用参数'；T'；“无法推断”；Swift中的错误

我试着练习“普通课”。我遇到了两个错误：

无法推断泛型参数“T”
对泛型类型“GenericObject”的引用需要中的参数

GenericManager

类中的两个错误。请参考以下代码。我如何解决这个问题

class User {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class Employee {
    var name: String
    var position: String
    init(name: String, position: String) {
        self.name = name
        self.position = position
    }
}

class GenericObject<T> {
    var items = [T]()
    init(forType: T.Type) {}

    func addObject(_ obj: T) {
        self.items.append(obj)
    }
}

class GenericManager {
    //issue: Generic parameter 'T' could not be inferred
    var objects = [GenericObject]()        

    //issue: Reference to generic type 'GenericObject' requires arguments in <...>
    func addObject(_ obj: GenericObject) {
        self.objects.append(obj)
    }
}

let u = User(name: "User")
let uo = GenericObject(forType: User.self)
uo.addObject(u)


let e = Employee(name: "Employee", position: "session manager")
let eo = GenericObject(forType: Employee.self)
eo.addObject(e)

let manager = GenericManager()
manager.addObject(uo)
manager.addObject(eo)

类用户{
变量名称：String
init（名称：String）{
self.name=名称
}
}
班级员工{
变量名称：String
变量位置：字符串
init（名称：String，位置：String）{
self.name=名称
self.position=位置
}
}
类GenericObject{
变量项=[T]（）
init（forType:T.Type）{}
func addObject（j:T）{
self.items.append（obj）
}
}
类GenericManager{
//问题：无法推断泛型参数“T”
变量对象=[GenericObject]（）
//问题：引用泛型类型“GenericObject”需要中的参数
func addObject（obj:generiobject）{
self.objects.append（obj）
}
}
设u=用户（名称：“用户”）
让uo=generiobject（forType:User.self）
uo.addObject（u）
设e=员工（姓名：“员工”，职位：“会议经理”）
让eo=GenericObject（forType:Employee.self）
eo.添加对象（e）
让manager=GenericManager（）
manager.addObject（uo）
管理器。添加对象（eo）

编译器需要知道

T

的类型，在本例中，您没有提供它

您可以这样做：

var objects = [GenericObject<YourTypeHere>]()

var objects = [GenericObject<Int>]()

class GenericManager<T> {
    var objects = [GenericObject<T>]()

    func addObject(_ obj: GenericObject<T>) {
        self.objects.append(obj)
    }
}

let u = User(name: "User")
let uo = GenericObject(forType: Any.self)
uo.addObject(u)


let e = Employee(name: "Employee", position: "session manager")
let eo = GenericObject(forType: Any.self)
eo.addObject(e)

let manager = GenericManager<Any>()
manager.addObject(uo)
manager.addObject(eo)

我注意到你更新了你的问题。知道你想要实现什么是很有帮助的，但无论如何我都会尽力帮助你

当您有一个泛型对象时，您需要在编译时告诉编译器泛型的类型，这就是为什么它抱怨不能推断类型，它需要知道

由于您希望能够将对象添加到

GenericManager

数组中，因此这两种情况下的generic必须相同，因此您可以这样修改类：

var objects = [GenericObject<YourTypeHere>]()

var objects = [GenericObject<Int>]()

class GenericManager<T> {
    var objects = [GenericObject<T>]()

    func addObject(_ obj: GenericObject<T>) {
        self.objects.append(obj)
    }
}

let u = User(name: "User")
let uo = GenericObject(forType: Any.self)
uo.addObject(u)


let e = Employee(name: "Employee", position: "session manager")
let eo = GenericObject(forType: Any.self)
eo.addObject(e)

let manager = GenericManager<Any>()
manager.addObject(uo)
manager.addObject(eo)

请记住，这将失去泛型所具有的任何优势，您可以做的是创建一个协议或公共超类，并使用它而不是

any

，但这取决于您试图实现的目标

---

如果您还有任何问题，请添加注释，而不是默默地更新您的问题。

编译器需要知道

T

的类型，在这种情况下，您没有提供它

您可以这样做：

var objects = [GenericObject<YourTypeHere>]()

var objects = [GenericObject<Int>]()

class GenericManager<T> {
    var objects = [GenericObject<T>]()

    func addObject(_ obj: GenericObject<T>) {
        self.objects.append(obj)
    }
}

let u = User(name: "User")
let uo = GenericObject(forType: Any.self)
uo.addObject(u)


let e = Employee(name: "Employee", position: "session manager")
let eo = GenericObject(forType: Any.self)
eo.addObject(e)

let manager = GenericManager<Any>()
manager.addObject(uo)
manager.addObject(eo)

我注意到你更新了你的问题。知道你想要实现什么是很有帮助的，但无论如何我都会尽力帮助你

当您有一个泛型对象时，您需要在编译时告诉编译器泛型的类型，这就是为什么它抱怨不能推断类型，它需要知道

由于您希望能够将对象添加到

GenericManager

数组中，因此这两种情况下的generic必须相同，因此您可以这样修改类：

var objects = [GenericObject<YourTypeHere>]()

var objects = [GenericObject<Int>]()

class GenericManager<T> {
    var objects = [GenericObject<T>]()

    func addObject(_ obj: GenericObject<T>) {
        self.objects.append(obj)
    }
}

let u = User(name: "User")
let uo = GenericObject(forType: Any.self)
uo.addObject(u)


let e = Employee(name: "Employee", position: "session manager")
let eo = GenericObject(forType: Any.self)
eo.addObject(e)

let manager = GenericManager<Any>()
manager.addObject(uo)
manager.addObject(eo)

请记住，这将失去泛型所具有的任何优势，您可以做的是创建一个协议或公共超类，并使用它而不是

any

，但这取决于您试图实现的目标

---

如果您还有任何问题，请添加注释，而不是默默地更新您的问题。

您遇到的问题是您试图使用泛型，但希望在

GenericManager

中忽略它，并存储对不同类型对象的引用

考虑一下——当您调用

manager.objects[0]

时，您希望返回什么

您可以按照EmilioPelaez的建议，使用

Any

通过类型擦除来解决此问题。然而，这通常是一种代码气味，它会导致在整个代码中进行黑客攻击

一种替代方法是使用

enum

指定要表示的不同类型的数据：

enum GenericObject {
    case users([User])
    case employees([Employee])
}
...
let uo = GenericObject.users([ u ])
...
let eo = GenericObject.employees([ e ])

---

现在，当您访问

GenericManager

中的属性时，您需要切换不同的支持类型，并且当您添加新类型时，您需要在使用

genericom对象时实现代码。您遇到的问题是您正试图使用泛型，但是希望在
GenericManager
中忽略这一点，并存储对不同类型对象的引用

考虑一下——当您调用
manager.objects[0]
时，您希望返回什么

您可以按照EmilioPelaez的建议，使用
Any
通过类型擦除来解决此问题。然而，这通常是一种代码气味，它会导致在整个代码中进行黑客攻击

一种替代方法是使用
enum
指定要表示的不同类型的数据：

enum GenericObject {
    case users([User])
    case employees([Employee])
}
...
let uo = GenericObject.users([ u ])
...
let eo = GenericObject.employees([ e ])

现在，当您访问
GenericManager
中的属性时，您需要切换支持的不同类型，当您添加新类型时，您需要在使用
genericom对象时实现代码