我已经定义与名为CanStack
相关联的类型Item
协议:
CanStack.swift
// protocol definition
protocol CanStack:
ExpressibleByArrayLiteral, CustomStringConvertible
{
associatedtype Item
var items:[Item] { get }
init()
mutating func push(_ items: [Item])
mutating func pop() -> Item?
}
// protocol extension (default behavior)
extension CanStack {
public var isEmpty: Bool { return items.isEmpty }
// init by array
public init(_ items:[Item]) {
self.init()
self.push(items)
}
// init by variadic parameter
public init(_ items:Item...){
self.init()
self.push(items)
}
// push items by variadic parameter
public mutating func push(_ items:Item...){
self.push(items)
}
}
// conform to ExpressibleByArrayLiteral
extension CanStack {
public init(arrayLiteral items:Item...){
self.init()
self.push(items)
}
}
// conform to CustomStringConvertible
extension CanStack {
public var description: String {
return "["
+ items.map{"\($0)"}.joined(separator:", ")
+ " ⇄ in/out"
}
}
和限定的StackStruct
结构符合该协议,这个通用结构具有类型参数Item
(与上面的相关联的类型完全相同的名称):
StackStruct.swift
public struct StackStruct<Item> {
public private(set) var items = [Item]()
public init() { }
mutating public func push(_ items:[Item]) {
self.items += items
}
@discardableResult
mutating public func pop() -> Item? {
return items.popLast()
}
}
// adopt CanStack protocol
extension StackStruct: CanStack { }
然后我定义另一类Stack
阶协调到协议太:
Stack.swift
public class Stack<Item> {
public private(set) var items = [Item]()
public required init() {}
public func push(_ newItems:[Item]) {
items += newItems
}
@discardableResult
public func pop() -> Item? {
return items.popLast()
}
}
// adopt CanStack protocol
extension Stack: CanStack { }
我有3个测试案例:
测试Cases.swift
func testStackStruct() {
// init
var s1: StackStruct = [1,2,3] // expressible by array literal
var s2 = StackStruct([4,5,6]) // init by array
var s3 = StackStruct(7, 8, 9) // init by variadic parameter
// push
s1.push([4,5]) // array
s2.push(10, 11) // variadic
s3.push(20) // variadic
// pop
for _ in 1...4 { s1.pop() }
s2.pop()
s3.pop()
// print these stacks
example("stack struct", items:[s1,s2,s3])
}
func testStackClass_Var() {
// init
var s4: Stack = [1,2,3] // ⚠️ warning: s4 was never mutated; consider changing to let ...
var s5 = Stack([4,5,6]) // init by array
var s6 = Stack(7, 8, 9) // init by variadic parameter
// push
s4.push([4,5]) // array
s5.push(10, 11) // variadic
s6.push(20) // variadic
// pop
for _ in 1...4 { s4.pop() }
// print these stacks
example("stack class", items: [s4,s5,s6])
}
func testStackClass_Let() {
// init
let s7: Stack = [1,2,3] // expressible by array literal
let s8 = Stack([4,5,6]) // init by array
let s9 = Stack(7, 8, 9) // init by variadic parameter
// push
s7.push([4,5]) // array
s8.push(10, 11) // ⛔ Error: Extra argument in call
s9.push(20) // ⛔ Error: Cannot convert value of type 'Int' to expected argument type '[Int]'
// pop
for _ in 1...4 { s7.pop() }
// print these stacks
example("stack class", items: [s7,s8,s9])
}
我可以运行没有任何问题的第一个测试用例testStackStruct()
:
testStackStruct()
的输出
[1 ⇄ in/out
[4, 5, 6, 10 ⇄ in/out
[7, 8, 9 ⇄ in/out
并运行testStackClass_Var()
情况下,只有一个编译器警告:
⚠️ warning: s4 was never mutated; consider changing to let ...
testStackClass_Var()
的输出
[1 ⇄ in/out
[4, 5, 6, 10, 11 ⇄ in/out
[7, 8, 9, 20 ⇄ in/out
但testStackClass_Let()
情况下甚至无法编译成功,我有两个编译器错误:
s8.push(10, 11) // ⛔ Error: Extra argument in call
s9.push(20) // ⛔ Error: Cannot convert value of type 'Int' to expected argument type '[Int]'
的情况下testStackClass_Var()
和testStackClass_Let()
情况之间的唯一区别是我是否使用一个或var
let
宣布这些栈实例。
我想不通的地方或我在做什么错了,可有人帮忙吗?谢谢。
附:
我的小助手功能:
example.swift
import Foundation // string.padding() needs this
// print example
// usage:
// example("test something", items: [a,b,c]) {
// // example code here ...
// }
public func example<T>(
_ title: String, // example title
length: Int = 30, // title length
items: [T]? = nil, // items to print
run: (()->Void)? = nil // example code (optional)
){
// print example title
print(
("----- [ " + title + " ] ")
.padding(toLength: length, withPad: "-", startingAt: 0)
)
// run example
if let run = run { run() }
// print items if provided
if let items = items {
items.forEach{ print($0) }
}
// new line
print()
}
你的
public func push(_ newItems:[Item]) {
是public class Stack<Item>
的方法,该方法是引用类型,因此可以称之为上一个常数:
let s4: Stack = [1,2,3]
s4.push([4,5])
在另一方面,一个可变方法
public mutating func push(_ items:Item...)
是protocol CanStack
,其可以通过结构被采用,以及的延伸的方法,因此它需要一个变量。这就是为什么
let s8 = Stack([4,5,6]) // init by array
s8.push(10, 11) // Error: Extra argument in call
不能编译。
这里是一个短示例演示问题:
protocol P {
mutating func foo()
mutating func bar()
}
extension P {
mutating func bar() {}
}
class C: P {
func foo() {}
}
let c = C()
c.foo()
c.bar() // Cannot use mutating member on immutable value: 'c' is a 'let' constant
其根本原因(我理解从下面列出的来源)是一个称为上的参考类型mutating func
不仅是允许的变异self
的属性,而且还由一个新的值来替换self
。
如果P
被声明为一类协议而不是(以及mutating
关键字被移除)将编译:
protocol P: class {
func foo()
func bar()
}
extension P {
func bar() {}
}
相关资源:
但testStackClass_Let()的情况下甚至无法编译成功,我有两个编译器错误:
s8.push(10, 11) // ⛔ Error: Extra argument in call
s9.push(20) // ⛔ Error: Cannot convert value of type 'Int' to expected argument type '[Int]'
所述testStackClass_Var()的情况下和testStackClass_Let()情况之间的唯一区别是我是否使用VAR或让宣布这些栈实例。
它是所有关于使用上斯威夫特结构不同诱变作用。这里是一个详细的解答:Thanks to Natasha-the-Robot