Generics 两个类或结构的泛型函数

在我正在进行的项目中，我有两个不同的类，

Array

和

Matrix

。我想在这些类上应用函数实现

Array->Array

或

Matrix->Matrix

我现在有

func f(x: Array) -> Array{
    return x+1 // generic but is not always this simple
}
func f(x: Matrix) -> Matrix{
    return x+1
}

如何使一个函数同时接受两个类？我见过一些依赖Equatable和其他内置协议的示例，但我只想使用这两个类。

试试：

func f<T>(x: T) -> T {
    return x + 1
}

func f（x:T）->T{
返回x+1
}

您需要定义一个泛型函数，就像Gary Makin描述的那样，但它可以为编译器提供更多关于传入内容的信息。您要做的是定义一个协议来描述将在函数中使用的类成员/方法/运算符，然后扩展

数组

和

矩阵

，以符合该协议。最后，将该协议添加为泛型函数的约束，编译器将了解，只有符合该协议的类型（数组和矩阵现在可以这样做）才能与该函数一起使用，并且一切都将正常工作

下面是一个包含两个简单自定义类的示例，MyTypeOne和MyTypeTwo。它们都有一个私有实例变量

counter

（一个定义为

Int

，另一个定义为

Double

）和

incrementBy

方法，该方法采用

Int

并递增内部计数器。不是很有用，但它们有助于说明上述要点：

struct MyTypeOne {
    var counter: Int = 0
    mutating func incrementBy(amt: Int) {
        counter += amt
    }
}
struct MyTypeTwo {
    var counter: Double = 0.0
    mutating func incrementBy(amt: Int) {
        counter += Double(amt)
    }
}

我有一个函数

f（）

，我希望能够使用这两种类型调用它——我将把它实现为一个泛型：

func f<T>(var x: T) -> T {
    x.incrementBy(1)
    return x
}

MyTypeOne

和

MyTypeTwo

的扩展是空的，因为它们已经实现了协议——这些扩展只是向编译器声明了该实现。最后，我们准备用协议约束更新我们的通用函数：

func f<T: MyIncrementable>(var x: T) -> T {
    x.incrementBy(1)
    return x
}

func f（变量x:T）->T{
x、 递增（1）
返回x
}

---

希望这有帮助

我有，但我得到编译器错误关于

T不能转换为矩阵

或触发器。我想知道这是否是因为矩阵的+运算与编译器期望的不一样。（我也在学习这个。）是的，一个简单的

返回x

有效。当我尝试访问我的类的特定成员时，我得到了

T没有名为
的成员。在两者中添加一个“PlusOne”成员，并使用该成员而不是“+1”？
func f<T: MyIncrementable>(var x: T) -> T {
    x.incrementBy(1)
    return x
}