|Swift|C++
:-:|:-:|:-:
用到的部分关键字|protocol,mutating, extension, override|virtual, override
** Swift 中**协议使用protocol 声明一个协议:
protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
而类,枚举,和结构体都可以遵循协议:
class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int = 69105
func adjust() {
simpleDescription += " Now 100% adjusted."
}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
struct SimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() {
simpleDescription += " (adjusted)"
}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
练习: 实现一个遵循了这个协议的枚举
注意, SimpleStructure 中使用了mutating 来标记一个将会修改结构体的方法. 而在 SimpleClass` 中并不需要这么做, 这是因为类中的方法通常都会修改类属性(类的性质).
而用extension 来为现有的类型添加功能, 就像添加诸如新方法和计算属性之类. 您可以使用扩展来为在其他地方声明的类型添加协议一致性，甚至可以将其添加到从库或框架中导入的类型:
extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number \(self)"
}
mutating func adjust() {
self += 42
}
}
print(7.simpleDescription)
练习: 给 Double 类型写一个扩展，添加 absoluteValue 功能。
你可以就是使用其他类型名一样使用协议名, 例如,创建一个有不同类型但是都实现了一个协议的对象集合.当你处理类型是协议的值时, 协议外定义的方法不可用:
let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty) // Uncomment to see the error
即使protocol 变量运行时的类型是simpleClass, 编译器会把它当成ExampleProtocol. 这表示你不能调用类在它实现的协议之外实现的方法或属性.
swift 中的协议或者扩展都是给类添加额外的方法, 只是使用场景不同. 而swift 本身又不限制类是否是单根继承.
在** C++中**则没有协议或扩展的东西, 只有类的多重继承和虚继承. 但即使如此, 借助于多重继承和虚继承, C++实现Swift 的协议或扩展也不难.
先理解下继承这个概念, 继承就像是生物学上的遗传,比如通俗的解释就是你继承了父母的所有基因, 有的显性基因和隐性基因. 但继承的细节更细, 尤其是多重继承和虚继承上的规则, 这些规则决定了,父类中的内容是否能够遗传给子类, 以何种方式遗传给子类. 这个规则当然就决定了子类的对象能否使用遗传而来的内容.
举个例子:
#include <iostream>
using namespace std;
class A {
public: // 访问控制
A(): a(5) {
}
int a;
auto doSomething() -> void {
cout << a << endl;
}
};
class B : public A { // 以何种方式继承 A?
};
int main() {
B b;
b.doSomething();
return 0;
}
注意,上例中的类A 中的访问控制表示以下所有内容对外公开. 而类B中继承 A 时采用了 public的方式继承,表示公开的继承 A.其中的区别是:
之前提到
class 和struct 的区别只是有不同的默认访问说明符, 而它们在定义子类时也有相应的区别:class 默认是私有的方式继承,struct 默认是公有的方式继承.
class A { /* ... */};
struct B : A { /* ... */}; // 默认 public 继承( 不推荐, 采用默认方法, 应该显式的写出继承方式)
class C : A { /* ... */ }; // 默认 private 继承( 不推荐, 采用默认方法, 应该显式的写出继承方式)
因此, 人们常常有一种错觉,认为使用struct和class 定义的类之间有更深层次的差别. 事实上, 唯一的差别就是默认成员访问说明符及默认派生访问说明符; 除此之外, 再无其他不同之处.
再来看多继承的例子:
#include <iostream>
using namespace std;
class A {
public: // 访问控制
A(): a(5) {
}
int a;
auto doSomething() -> void {
cout << a << endl;
}
};
class B {
public:
B(): b(6) {
}
int b;
auto doSomething() -> void {
cout << b << endl;
}
};
class C : public A, public B {
};
int main() {
C c;
cout << c.a << endl;
cout << c.b << endl;
return 0;
}
看起来问题不大, 但你试试在main()中继续写一行c.doSomething(); 你将得到多义性冲突: 因为 doSomething这个名字在A 和B 中都用, 编译器不知道应该使用哪个.
你可以使用作用域运算符解决这个问题:c.A::doSomething();
再来看虚继承是怎么回事, 仅仅是多了个virtual 吗?:
#include <iostream>
using namespace std;
class A {
public: // 访问控制
A(): a(5) {
}
int a;
auto doSomething() -> void {
cout << a << endl;
}
};
class B : virtual public A { // 在继承派生类时,使用 virtual 关键字定义一个虚继承
public:
B() {
}
};
class C : virtual public A {
public:
C() {
}
};
class D : public B, public C {
public:
D() {
}
};
int main() {
D d;
d.a++;
d.doSomething();
A a(d); // 使用多态
a.doSomething();
return 0;
}
当继承树中出现交叉时, 通常会用到虚继承.
我先解释下继承中会发生的事情, 当B 继承 A 时, 创建 B的对象时, B 对象内容包含了完整的A 对象, 此时B 对象完全可以当做A 对象来使用, 就是就所谓的多态.
那么, 当B 继承A, C 继承A 时, 此时D 多继承了B 和C时, 会发生什么?
此时, 创建D 对象时, D 对象内部将包含完整的B 对象和C 对象. 而B 对象内部又有一个A 对象, C 对象内部同样也有一个A 对象. 这样, 我们创建的D 对象内部实际上有两个A 对象.
再举个例子在来理解这种现象:
而此时, 虚继承的意义在哪里?
那么, 虚继承和多重继承实际上, 就能实现Swift 中的协议和扩展. 因为, 协议和扩展,无外乎是向某类型添加一些方法.
