使用 "as"快速向上转换，这是怎么回事？

Question

protocol P1 {
    func doP1()
}
protocol P2 {
    func doP2()
}

class B {
}
class D : B, P1, P2 {
    func doP2() {}
    func doP1() {}
}

let s = D()
print(type(of:(D() as P1)))
print(type(of:(D() as B)))
print(type(of:[D(), D()] as [P1]))

所以当我运行它时，我得到:

D
D
Array<P1>

好的，我来自 C++ 世界。我想第一行会给我一个 P1 类型，第二行会给我一个 B 类型，第三行会给我一个 P1 数组。所以我得到了 P1 的数组，但这似乎与第一行不一致，第一行表明它实际上是 D 而不是 P1。那么给出了什么？显然，我不了解 Swift 的这个角落。当你向上转型时，它不应该忽略这个类型信息吗？编译器是不是太聪明了，因为它真的知道类型？

Answer 1

Is the compiler too smart, because it really knows the types?

编译器只知道你告诉它什么。它认为 D() as B 是一个 B。

但你没有问编译器。当您说 print 并运行应用程序时，您是在与运行时对话。多态性表示一个对象在内部是它实际的类型，而不是其他类型。您可以将 D() 转换为 P1 或 B，但它仍然是 D。您运行应用程序，运行时会发现这一点，并告诉您它发现了什么。

Array 的情况略有不同。在 Swift 中，Array 是泛型，必须解析。您关于如何解决它的陈述是决定性的，即使对于运行时也是如此:

print(type(of:[D(), D()] as [P1]))
print(type(of:[D(), D()] as [P2]))
print(type(of:[D(), D()] as [B]))
/*
 Array<P1>
 Array<P2>
 Array<B>
*/

换句话说，运行时不会费心去探索这些数组并告诉您它们的最小公分母，实际上；它只是告诉你类型。但是，如果您自己探索这些阵列，就会发现其中的内容:

for element in ([D(), D()] as [P1]) { print(type(of:element)) }
// D D