Swift泛型类中如何实例化遵循ItemProtocol的<T>类型实例？

错误原因 #

编译报错的核心在于：ItemProtocol仅定义了属性要求，并未约束遵循该协议的类型必须实现init(itemId:parameter2:parameter3:)初始化器。虽然你的Item结构体因成员属性自动生成了该初始化器，但编译器无法保证所有遵循ItemProtocol的类型都提供这个初始化方法，因此直接调用T(itemId:...)会触发编译错误。

另外注意：你的AClassProtocol中关联类型命名为ItemProtocol，这会和全局的ItemProtocol协议名冲突，建议修改为ItemType避免混淆。

解决方案 #

方案1：给协议添加初始化器要求（最直接） #

修改ItemProtocol，明确要求所有遵循者必须实现指定初始化器：

protocol ItemProtocol: Codable {
    var itemId: String { get set }
    var parameter2: String { get set }
    var parameter3: String { get set }
    
    // 添加初始化器约束
    init(itemId: String, parameter2: String, parameter3: String)
}

• 对于结构体Item，由于已有匹配的成员初始化器，会自动满足该协议要求；
• 如果是类遵循该协议，需要给初始化器添加required关键字（确保子类也实现该初始化器）。

同时修正AClassProtocol的关联类型命名：

protocol AClassProtocol {
    associatedtype ItemType: ItemProtocol

    func createItem() -> [ItemType]
}

class ClassA<T: ItemProtocol>: AClassProtocol {
    typealias ItemType = T
    private lazy var items = [T]()
    
    func createItem() -> [T] {
        let newItem = T(itemId: "someDummyID",
                        parameter2: "ABC",
                        parameter3: "BCA") 
        items.append(newItem)
        return items
    }
}

方案2：通过闭包注入初始化逻辑（低耦合） #

如果不想修改原协议，可以在ClassA初始化时传入一个创建T实例的闭包，将初始化逻辑外部化：

protocol AClassProtocol {
    associatedtype ItemType: ItemProtocol
    func createItem() -> [ItemType]
}

class ClassA<T: ItemProtocol>: AClassProtocol {
    typealias ItemType = T
    private lazy var items = [T]()
    private let itemCreator: (String, String, String) -> T
    
    // 初始化时注入创建闭包
    init(itemCreator: @escaping (String, String, String) -> T) {
        self.itemCreator = itemCreator
    }
    
    func createItem() -> [T] {
        let newItem = itemCreator("someDummyID", "ABC", "BCA")
        items.append(newItem)
        return items
    }
}

// 使用示例
let classA = ClassA<Item> { id, p2, p3 in
    Item(itemId: id, parameter2: p2, parameter3: p3)
}

这种方式让ClassA无需关心T的具体初始化细节，灵活性更高。

方案3：新增辅助协议约束（折中方案） #

定义一个仅包含初始化器要求的辅助协议，让T同时遵循该协议：

// 辅助协议，定义初始化器要求
protocol ItemInitializable {
    init(itemId: String, parameter2: String, parameter3: String)
}

protocol ItemProtocol: Codable {
    var itemId: String { get set }
    var parameter2: String { get set }
    var parameter3: String { get set }
}

// 让Item遵循辅助协议（自动满足）
extension Item: ItemInitializable {}

protocol AClassProtocol {
    associatedtype ItemType: ItemProtocol & ItemInitializable
    func createItem() -> [ItemType]
}

class ClassA<T: ItemProtocol & ItemInitializable>: AClassProtocol {
    typealias ItemType = T
    private lazy var items = [T]()
    
    func createItem() -> [T] {
        let newItem = T(itemId: "someDummyID",
                        parameter2: "ABC",
                        parameter3: "BCA") 
        items.append(newItem)
        return items
    }
}

这种方式无需修改原ItemProtocol，但需要每个遵循ItemProtocol的类型额外遵循辅助协议。

内容的提问来源于stack exchange，提问作者Meeshoo