【Swift 3 && C++11】 概览(6): Swift协议和扩展 与 C++多重继承与虚继承

2017-01-14 10:46:35来源:http://www.jianshu.com/p/8bf9042077bc作者:aLittleZ人点击



类的继承性













SwiftC++
用到的部分关键字
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.其中的区别是:



类中的访问控制和类的继承方式的相互作用


之前提到classstruct 的区别只是有不同的默认访问说明符, 而它们在定义子类时也有相应的区别:class 默认是私有的方式继承,struct 默认是公有的方式继承.


class A { /* ... */};
struct B : A { /* ... */}; // 默认 public 继承( 不推荐, 采用默认方法, 应该显式的写出继承方式)
class C : A { /* ... */ }; // 默认 private 继承( 不推荐, 采用默认方法, 应该显式的写出继承方式)

因此, 人们常常有一种错觉,认为使用structclass 定义的类之间有更深层次的差别. 事实上, 唯一的差别就是默认成员访问说明符及默认派生访问说明符; 除此之外, 再无其他不同之处.


再来看多继承的例子:


#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这个名字在AB 中都用, 编译器不知道应该使用哪个.


你可以使用作用域运算符解决这个问题: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 多继承了BC时, 会发生什么?


此时, 创建D 对象时, D 对象内部将包含完整的B 对象和C 对象. 而B 对象内部又有一个A 对象, C 对象内部同样也有一个A 对象. 这样, 我们创建的D 对象内部实际上有两个A 对象.


再举个例子在来理解这种现象:



多继承时, 对象内部的出现重复的子对象现象

而此时, 虚继承的意义在哪里?



虚继承的意义

那么, 虚继承和多重继承实际上, 就能实现Swift 中的协议和扩展. 因为, 协议和扩展,无外乎是向某类型添加一些方法.




最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台