Generics Swift中的泛型函数 我是C++的，我对SWIFT .的泛型函数有点困惑。 在C++中，我可以做到： class Entity { template <typename T> T *getComponent() { return (T *)(listComponent_[typeid(T).name()]); } };

我想在Swift中重现这一点，但我不知道如何实现它

在Swift中，我必须为函数定义一个参数来确定我的类型

迅速：

class Entity
{
    func get<T>() -> T
    {
         return ??
    }
}

类实体
{
func get（）->T
{
返回？？
}
}

我希望能够做到：

Entity().get<LifeComponent>()

Entity（）.get（）

---

你能帮我吗？

你需要告诉编译器它能用

T

做什么，否则它就没什么用了

---

Swift必须在编译时知道将传递给

get（）

函数的内容。它不会盲目地接受您提供的任何内存块。必须告诉编译器内存中将包含什么

以下是描述如何在Swift中使用泛型的文档，它应该回答您的所有问题：

另一个选择是你可以使用Objto-C或者C++。

---

大多数iOS和OSX软件都是用Objective-C或C/C++编写的。目前几乎没有任何东西是用Swift编写的，该语言距离成为完全可行的语言还有几年的时间。大部分用Swift编写的项目可以与用Objective-C或C/C++编写的代码很好地集成。

这是我所能理解的最接近于您尝试做的事情的精神

在本例中，我们定义了一个协议，该协议告诉

实体

如何获取组件的名称。将其显式化将使其比任何获取变量类型名称或类名称的黑客都更加可靠和易读，所有这些都有多个限制。请注意，如果组件都有一个公共的超类，或者即使它们都是

NSObject

的子类，那么使用协议方法可能是最好的，因为实体中的东西，无论它们是什么，都应该有一些公共的共享接口，否则你根本不知道你能用它们做什么

// Mostly the Component protocol is needed so that we can create an
//  item with no arguments.
protocol NamedComponent {
    class var ComponentName : String { get }
}

// Make Int an allowable component
extension Int : NamedComponent {
    static let ComponentName = "Int"
}

extension String : NamedComponent {
    static let ComponentName = "String"
}

// make a class a NamedComponent, note the different syntax between
// adding a class constant to a class here and to a struct or base type
// above
class SomeComponent : NamedComponent {
    class var ComponentName : String { get { return "SomeComponent" } }
}

class Entity {
    // The component library
    var components = [String:NamedComponent]()

    // add a component to the library by class name
    func register<T:NamedComponent>(value:T) {
        components[T.ComponentName] = value
    }

    // Reference a component by class name
    func get<T:NamedComponent>() -> T? {
        return components[T.ComponentName] as? T
    }
}

// Create the entity
let entity = Entity()

// Add a dummy component
entity.register(45)
entity.register("string")
entity.register(SomeComponent())

// Fetch a dummy component
let int : Int? = entity.get()
println("\(int)")

let str : String? = entity.get()
println("\(str)")

let comp : SomeComponent? = entity.get()
println("\(comp)")

//主要需要组件协议，以便创建
//没有参数的项。
协议名称组件{
类var ComponentName:字符串{get}
}
//使Int成为允许的组件
扩展名Int:NamedComponent{
静态let ComponentName=“Int”
}
扩展字符串：NamedComponent{
静态let ComponentName=“字符串”
}
//将类设为NamedComponent，请注意
//将类常量添加到此处的类以及结构或基类型
//在上面
类SomeComponent:NamedComponent{
类var ComponentName:String{get{return“SomeComponent”}
}
类实体{
//组件库
var components=[String:NamedComponent]（）
//按类名将组件添加到库中
func寄存器（值：T）{
组件[T.ComponentName]=值
}
//按类名引用组件
func get（）->T{
将组件[T.ComponentName]返回为？T
}
}
//创建实体
让实体=实体（）
//添加虚拟组件
实体登记册（45）
实体。寄存器（“字符串”）
entity.register（SomeComponent（））
//获取一个虚拟组件
让int:int？=entity.get（）
println（“\（int）”）
让str:Stringentity.get（）
println（“\（str）”）
让comp:SomeComponent？=entity.get（）
println（“\（comp）”）
<>代码> 我不知道C++语法，但你想要的是这样的？
class Entity {
    var list:[Any] = []

    func register(obj:Any) {
        list.append(obj)
    }
    func getComponent<T>(type:T.Type) -> T? {
        for obj in list {
            if let instance = obj as? T {
                return instance
            }
        }
        return nil
    }
}

let cls = Entity()
cls.register(1)
cls.register("This is a String")
cls.register(UIView())
cls.register(1.01)

cls.getComponent(String) // -> Optional("This is a String")

类实体{
变量列表：[任何]=[]
func寄存器（对象：任何）{
list.append（obj）
}
func getComponent（类型：T.type）->T{
对于列表中的obj{
如果let instance=obj as？T{
返回实例
}
}
归零
}
}
设cls=Entity（）
cls.寄存器（1）
cls.register（“这是一个字符串”）
cls.register（UIView（））
cls.寄存器（1.01）
cls.getComponent（字符串）/->可选（“这是一个字符串”）
刚刚偶然发现了同样的问题。如何调用泛型函数

为我找到了一个解决方案，也许对你也有用。我想从字典中初始化一些结构。我的所有结构都实现一个协议
字典可初始化

struct MyStruct: DictionaryInitializable {
    ...
    init?(dictionary: [String: AnyObject]) {
        ...
    }
}

我还有一个具有以下方法的解析器：

func parse<T: DictionaryInitializable>(dict: [String: AnyObject]) -> T? {
    return T(dictionary: dict)
}

这适用于Xcode 7.3和Swift 2.2。在此之前从未在版本中进行过测试。
。你不必“弄明白”这一点：使用谷歌和阅读文档就足够了。我知道如何创建通用函数，以及如何使用它。我只是想知道是否有一种方法可以让一个类在C++中有一个类似于SWIFT的类型。“Swift必须知道，在编译时，你将传递给GET（）函数。”<代码> GET（））/Cuth>函数不带任何参数；没有什么是“传递进来的”。
func parse<T: DictionaryInitializable>(dict: [String: AnyObject]) -> T? {
    return T(dictionary: dict)
}

let parsedStruct: MyStruct = parser.parse(dictionary)