Swift泛型:需要一种类型的加法和乘法能力

Question

我正在尝试Swift书中的一些例子,即他们引入下标选项的矩阵示例.这是我的代码:

struct Matrix<T> {
    let rows: Int, columns: Int
    var grid: T[]

    var description: String {
        return "\(grid)"
    }

    init(rows: Int, columns: Int, initialValue: T) {
        self.rows = rows
        self.columns = columns
        grid = Array(count: rows * columns, repeatedValue: initialValue)
    }

    func indexIsValidForRow(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }

    subscript(row: Int, column: Int) -> T {
        get {
            assert(indexIsValidForRow(row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValidForRow(row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}

这主要是从书中复制的.这一行的主要区别在于:

struct Matrix<T>

据我所知,这告诉编译器我的Matrix类可以保存类型为T的值,由使用此类的代码指定.现在,我想确保可以比较类型T,所以我可以这样写:

struct Matrix<T: Equatable>

如果我想比较2个矩阵,这可能是有用的,这意味着要比较它们的值.我还希望提供给求和两个矩阵的能力,因此我也应该添加到这个线路要求由矩阵的用户给出的类型"T"可以被添加的协议:

struct Matrix<T: Equatable, "Summable">

同样,我也想说:

struct Matrix<T: Equatable, "Summable", "Multipliable">

问题1:我可以使用哪种协议名称？我怎样才能做到这一点？

在相关的说明中,要使用'+'运算符添加附加功能,我应该声明一个这样的函数(这也适用于乘法):

@infix func + (m1: Matrix<T>, m2: Matrix<T>) -> Matrix<T> {
    // perform addition here and return a new matrix
    return result
}

但是,Xcode不接受此代码.更具体地说,这) -> Matrix<T> {会产生错误:Use of undeclared type 'T'.我的意思<T>是结果将是一个矩阵,它具有相同类型的两个输入矩阵,但我可能完全搞乱了语法.

问题2:如何为添加结果提供类型信息？

Answer 1

这是第二个问题(但你真的应该问两个不同的问题):

@infix func + <T> (m1: Matrix<T>, m2: Matrix<T>) -> Matrix<T> { ... }

对于您的第一个问题:在解决之前,这里是为类型参数定义多个约束的语法:

struct Matrix<T where T: Equatable, T: Summable, T: Multipliable> {...}

或者,正如GoZoner在评论中写道:

struct Matrix<T: protocol<Equatable, Summable, Multipliable>> {...}

但我们不需要它.首先,定义新协议并列出所需的操作.你甚至可以扩展它Equatable:

protocol SummableMultipliable: Equatable {
    func +(lhs: Self, rhs: Self) -> Self
    func *(lhs: Self, rhs: Self) -> Self
}

然后,为要符合的类型提供扩展.在这里,对于Int和Double,扩展甚至是空的,因为所需的操作的实现是内置的:

extension Int: SummableMultipliable {}
extension Double: SummableMultipliable {}

然后,在type参数上声明您的类型约束:

struct Matrix<T: SummableMultipliable> { ... }

最后,你可以写这样的东西:

let intMat = Matrix<Int>(rows: 3, columns: 3, initialValue: 0)
let doubleMat = Matrix<Double>(rows: 3, columns: 3, initialValue: 0)
let i: Int = intMat[0,0]
let d: Double = doubleMat[0,0]

您需要的最后一件事是在运算符的定义中插入类型约束:

@infix func + <T: SummableMultipliable> (m1: Matrix<T>, m2: Matrix<T>) -> Matrix<T> { ... }