我有一个名为P的协议，它返回对象的副本：
protocol P {
func copy() -> Self
}
并且有一个实现P接口的类C：
class C : P {
func copy() -> Self {
return C()
}
}
然而，无论我将返回值设为Self，我都会得到以下错误：
无法将返回类型为 'C' 的返回表达式转换为返回类型 'Self'
我还尝试过返回C。
class C : P {
func copy() -> C {
return C()
}
}
这导致了以下错误：
非最终类'C'中的'method copy()'必须返回
Self以符合协议'P'
除了在定义'class C'时添加'final'前缀的情况外，没有其他可行的方案：
final class C : P {
func copy() -> C {
return C()
}
}
然而，如果我想要继承C类，则什么都行不通。有没有什么办法可以解决这个问题？
问题在于你做出了一个编译器无法证明你会遵守的承诺。
因此，你创建了这个承诺：调用copy()将返回其自身类型，完全初始化。
但是你却这样实现了copy()：
func copy() -> Self {
return C()
}
现在我是一个未覆盖copy()方法的子类。 我返回一个C，而不是完全初始化的Self（这是我承诺过的）。所以这不好。怎么样:
func copy() -> Self {
return Self()
}
好的，那段代码不能编译通过，即使它能编译通过，也没用。子类可能没有默认构造函数，所以 D() 可能甚至不合法。（见下文）
好吧，那怎么样：
func copy() -> C {
return C()
}
是的，但它并不返回 Self。它返回C。你仍然没有遵守承诺。
“但ObjC可以做到！”嗯，有点吧。主要是因为它不像Swift那样关心你是否遵守了承诺。如果在子类中未实现copyWithZone:，则可能无法完全初始化对象。编译器甚至不会警告你已经这样做了。
“但ObjC中的大多数内容都可以翻译成Swift，并且ObjC有NSCopying。” 是的，它确实有，这是它的定义：
func copy() -> AnyObject!
protocol Copyable {
func copy() -> AnyObject
}
那句话的意思是“我不保证你会得到任何东西。”你也可以这样说：
protocol Copyable {
func copy() -> Copyable
}
这是一个你可以兑现的承诺。
但是我们可以暂时考虑一下C++，并且记住有一个我们可以实现的承诺。我们可以承诺自己及所有子类将实现特定种类的初始化程序，并且Swift将执行此操作(因此可以证明我们在说实话):
protocol Copyable {
init(copy: Self)
}
class C : Copyable {
required init(copy: C) {
// Perform your copying here.
}
}
这就是你应该执行复制的方式。
我们可以更进一步，但它使用了 dynamicType，我还没有进行全面测试以确保它始终是我们想要的，但应该是正确的：
protocol Copyable {
func copy() -> Self
init(copy: Self)
}
class C : Copyable {
func copy() -> Self {
return self.dynamicType(copy: self)
}
required init(copy: C) {
// Perform your copying here.
}
}
func copy() -> C在之前的测试版中是有效的，并且它是一致的，因为协议符合性没有被继承。（现在似乎协议符合性被继承了，而func copy() -> C不起作用了。） - newacctinit(copy: C)而不是init(copy: Self) :( - fluidsonicAnyObject有很大的改进，但确实意味着您必须能够复制您的超类（因此您的子类属性必须有默认值，或者您必须使用fatalError()或类似的东西，这很丑陋）。如果您摆脱了Copyable协议，则问题会消失。只要您实现init(copy:)而不承诺这样做（但它也不会强制您在每个层面上实现init(copy:)），则所有内容都按预期运行。请参见http://stackoverflow.com/a/28795620/97337以及https://devforums.apple.com/message/1086442。 - Rob Napierself.dynamicType.init( ... )。 - pronebird有了Swift 2，我们可以使用协议扩展来实现这一点。
protocol Copyable {
init(copy:Self)
}
extension Copyable {
func copy() -> Self {
return Self.init(copy: self)
}
}
return Self(copy: self)（至少在Swift 2.2中）。 - jhrmnn有另一种实现你想要的方法，它涉及利用Swift的关联类型。这里是一个简单的例子：
public protocol Creatable {
associatedtype ObjectType = Self
static func create() -> ObjectType
}
class MyClass {
// Your class stuff here
}
extension MyClass: Creatable {
// Define the protocol function to return class type
static func create() -> MyClass {
// Create an instance of your class however you want
return MyClass()
}
}
let obj = MyClass.create()
实际上，有一个技巧可以在需要符合协议时轻松返回Self（gist）：
/// Cast the argument to the infered function return type.
func autocast<T>(some: Any) -> T? {
return some as? T
}
protocol Foo {
static func foo() -> Self
}
class Vehicle: Foo {
class func foo() -> Self {
return autocast(Vehicle())!
}
}
class Tractor: Vehicle {
override class func foo() -> Self {
return autocast(Tractor())!
}
}
func typeName(some: Any) -> String {
return (some is Any.Type) ? "\(some)" : "\(some.dynamicType)"
}
let vehicle = Vehicle.foo()
let tractor = Tractor.foo()
print(typeName(vehicle)) // Vehicle
print(typeName(tractor)) // Tractor
return Vehicle() as! Self。 - SimplGyfoo()的重写没有被强制执行，每个没有自定义实现foo()的Vehicle子类都会在autocast()中产生明显的崩溃。例如：class SuperCar: Vehicle {
}
let superCar = SuperCar.foo()无法将Vehicle实例向下转换为SuperCar - 因此在' autocast() '中强制解包nil会导致崩溃。 - freennnnfoo()，则不会崩溃。唯一的要求是类 Foo 必须有一个必需的初始化器才能按照下面所示的方式工作。`class Vehicle: Foo {public required init() {
// Some init code here
}
class func foo() -> Self {
return autocast(self.init())! // return autocast(Vehicle())!
}}class Tractor: Vehicle {
//Override is not necessary/*override class func foo() -> Self {
return autocast(Tractor())!
}*/}` - shawnynicoleSwift 5.1现在允许将强制转换为自身，as! Self
1> protocol P {
2. func id() -> Self
3. }
9> class D : P {
10. func id() -> Self {
11. return D()
12. }
13. }
error: repl.swift:11:16: error: cannot convert return expression of type 'D' to return type 'Self'
return D()
^~~
as! Self
9> class D : P {
10. func id() -> Self {
11. return D() as! Self
12. }
13. } //works
根据Rob的建议，可以使用关联类型使其更加通用。我稍微修改了示例以展示此方法的好处。
protocol Copyable: NSCopying {
associatedtype Prototype
init(copy: Prototype)
init(deepCopy: Prototype)
}
class C : Copyable {
typealias Prototype = C // <-- requires adding this line to classes
required init(copy: Prototype) {
// Perform your copying here.
}
required init(deepCopy: Prototype) {
// Perform your deep copying here.
}
@objc func copyWithZone(zone: NSZone) -> AnyObject {
return Prototype(copy: self)
}
}
我只是想表达一下我的看法。我们需要一个协议，返回应用于该协议的类型的可选项。我们还希望覆盖方法明确地返回类型，而不仅仅是Self。
关键在于，你可以定义一个关联类型，并将其设置为Self，然后使用该关联类型，而不是使用Self作为返回类型。
以下是旧的使用Self的方式...
protocol Mappable{
static func map() -> Self?
}
// Generated from Fix-it
extension SomeSpecificClass : Mappable{
static func map() -> Self? {
...
}
}
这是使用关联类型的新方式。请注意，返回类型现在是明确的，不再是'Self'。
protocol Mappable{
associatedtype ExplicitSelf = Self
static func map() -> ExplicitSelf?
}
// Generated from Fix-it
extension SomeSpecificClass : Mappable{
static func map() -> SomeSpecificClass? {
...
}
}
我曾经遇到过类似的问题，并想出了一些可能有用的东西，所以我想在这里分享一下供日后参考，因为这是我在寻找解决方案时发现的第一个地方之一。
如上所述，问题在于copy()函数的返回类型不明确。这可以通过将copy() -> C和copy() -> P函数分开来很清楚地说明：
因此，假设您定义协议和类如下：
protocol P
{
func copy() -> P
}
class C:P
{
func doCopy() -> C { return C() }
func copy() -> C { return doCopy() }
func copy() -> P { return doCopy() }
}
var aC:C = C() // aC is of type C
var aP:P = aC // aP is of type P (contains an instance of C)
var bC:C // this to test assignment to a C type variable
var bP:P // " " " P " "
bC = aC.copy() // OK copy()->C is used
bP = aC.copy() // Ambiguous.
// compiler could use either functions
bP = (aC as P).copy() // but this resolves the ambiguity.
bC = aP.copy() // Fails, obvious type incompatibility
bP = aP.copy() // OK copy()->P is used
protocol P
{
func copyAsP() -> P
}
class C:P
{
func copy() -> C
{
// there usually is a lot more code around here...
return C()
}
func copyAsP() -> P { return copy() }
}
除了使用associatedtype的方式之外，我建议将实例的创建移动到协议扩展的默认实现中。这样，符合协议的类就不必实现它，从而避免了代码重复：
protocol Initializable {
init()
}
protocol Creatable: Initializable {
associatedtype Object: Initializable = Self
static func newInstance() -> Object
}
extension Creatable {
static func newInstance() -> Object {
return Object()
}
}
class MyClass: Creatable {
required init() {}
}
class MyOtherClass: Creatable {
required init() {}
}
// Any class (struct, etc.) conforming to Creatable
// can create new instances without having to implement newInstance()
let instance1 = MyClass.newInstance()
let instance2 = MyOtherClass.newInstance()
[[[self class] alloc] init]。所以我的问题是，有没有一种类型安全的方式来调用当前类并调用init方法？ - aeubanksself.dynamicType()。你调用的初始化程序必须声明为required，因为在Swift中初始化程序并不总是被继承的。 - newacct