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> { ... }