属性
什么是属性？
- 属性（Property）可以将值与特定的类、结构体或者枚举联系起来
- 属性严格来说根据访问方式可以分为实例属性（Instance Property）、类型属性（Type Property）
与实例相关的属性（该节中属性均表示为实例相关的属性）
- 存储属性 特点：
- 类似于成员变量，存储在实例的内存中，
- 结构体、类可以定义存储属性，枚举不可以定义存储属性
规定：在创建类、结构体的实例时，必须为所有的存储属性设置一个合适的初始值
- 可以再初始化器里为存储属性设置一个初始值
- 可以分配一个默认的属性值作为属性定义的一部分
其实本质上是一样的（通过汇编可以证明，都是在init初始化方法中）
- 计算属性 特点：
- 本质就是方法（函数），不占用实例的内存
- 枚举、结构体、类都可以定义计算属性
其中： - set传入的新值默认叫做newValue，也可以自定义
- 只读计算属性只有get，没有set(set可以不写，即为只读)，此时可以简写
- 定义计算属性只能用var，不能用let（即使是只读计算属性），因为计算属性的值是可能根据存储属性发生变化的
//例1、存储属性、计算属性的举例
struct Circle {
var radius :Int //存储属性
var diameter :Int {//计算属性
set{
radius = newValue / 2
}
get{
radius * 2
}
}
}
var cir = Circle(radius: 10)
cir.radius = 20
print(cir.radius, cir.diameter)//输出：20 40
cir.diameter = 20
print(cir.radius, cir.diameter)//输出：10 20
//例2、只读计算属性的简写
struct Circle {
var radius :Int //存储属性
var diameter :Int {//计算属性
get{
radius * 2
}
}
var area :Int{//只读计算属性 简写形式
radius * radius
}
}
var cir = Circle(radius: 10)
cir.radius = 20
print(cir.radius, cir.diameter)//输出：20 40
//cir.diameter = 20//报错 只读计算属性
print(cir.diameter,cir.area)//输出：40 400
rawValue原理
前面讲过枚举，如果对枚举的原始值/关联值的分配内存有疑惑的，在这里可以解释
//rawValue的本质其实就是枚举实例的get方法 是不占用内存的
enum TestEnum :Int {
case test1 = 1, test2, test3, test4
var rawValue :Int {
get{
switch self {
case .test1:
return 2
case .test2:
return 3
case .test3:
return 4
case .test4:
return 5
}
}
}
}
print(TestEnum.test1.rawValue)//2 与此前定义原始值1不同
如何证明呢？将rawValue相关代码注释，断点调试 查看汇编
代码调试
实际上调用的就是rawValue这个计算属性的get方法
如何证明rawValue是只读的呢？赋值即会报错
翻译：无法分配给属性：“ rawValue”是不可变的
延迟存储属性（Lazy Stored Property）
- 使用lazy定义一个延迟存储属性 在第一次用到属性的时候才会进行初始化
如下例子，执行结果会有不同：
右侧的存储属性car为延迟存储属性 在p初始化时并没有初始化car 在p调用goout时 car才进行初始化
【注意】
- lazy属性必须是var，不能是let（ let必须在实例初始化方法完成之前就拥有值，lazy的本质是第一次用到时改变car对应内存地址的值）
- 如果多条线程同时第一次访问lazy属性，则无法保证属性只被初始化一次
- 当结构体（上栗为class）包含一个延迟存储属性时，只有var才能访问延迟存储属性（∵结构体为值类型）
属性观察器（Property Observer）
- 可以为非lazy的var属性设置属性观察器（可以类比OC中的kvo）
- willSet会传递新值，默认叫newValue,didSet会传递旧值，默认叫oldValue
- 在初始化器中设置属性不会触发willSet和didSet
//例.初始化器中设置属性不会触发
struct Circle {
var radius :Int {
willSet{
print("willset",newValue)
}
didSet{
print("didset",oldValue,radius)
}
}
var diameter :Int {
set{
radius = newValue / 2
}
get{
radius * 2
}
}
init() {
self.radius = 10
print("Circle init!")
}
}
var c = Circle()//输出：Circle init!
c.radius = 20
//输出：willset 20
// didset 10 20
属性观察器、计算属性 应用场景
属性观察器、计算属性 可以应用在全局变量、局部变量
inout再次研究
- 如果实参有物理内存地址，且没有属性观察器，直接将实参的内存地址传入函数（实参进行引用传递）
- 如果实参是计算属性 或者 设置了属性观察器 则会采取Copy In Copy Out的做法
- 第一步、调用该函数时，先复制实参的值，产生副本【get】
- 第二步、将副本的内存地址传入函数（副本进行引用传递），在函数内部修改副本的值
- 第三步、函数返回后，再将副本的值覆盖实参的值【set】
因此，inout本质就是引用传递(地址传递)
怎么证明上述结论是正确的呢？
struct Shape {
var width :Int
var side :Int {
willSet{
print("willSetSide",newValue)
}
didSet{
print("didSetSide",oldValue,side)
}
}
var girth :Int {
set{
width = newValue / side
print("SetGirth",newValue)
}
get{
print("GetGirth")
return width * side
}
}
func show() {
print("width = \(width),side = \(side),girth = \(girth)")
}
}
func change(_ num: inout Int){
num = 20
}
var shape1 = Shape(width: 10, side: 4)
change(&shape1.width)
shape1.show()
print("----------------")
change(&shape1.side)
shape1.show()
print("----------------")
change(&shape1.girth)
shape1.show()
/*输出：
GetGirth
width = 20,side = 4,girth = 80
----------------
willSetSide 20
didSetSide 4 20
GetGirth
width = 20,side = 20,girth = 400
----------------
GetGirth
SetGirth 20
GetGirth
width = 1,side = 20,girth = 20
*/
-
先看shape1.width，查看汇编
传递进去的是shape1的地址，也就是width变量的地址 -
再看shape1. side
先将shape1+8个字节对应的值（即side的值）赋值给-0x28(rbp)的地址 然后再将改地址传如change()，再调用set方法 此时就会触发willSet访问新值 didSet将旧值返回 然后赋新值 再看shape1. girth 查看汇编 重点在3个蓝框 和3条红线
首先调用get方法，将该值赋值给-0x20(rbp)这个地址 再将这个地址传进change（）修改这个临时地址的值 然后在调用set方法，将这个值赋值给shape1.girth
类型属性（Type Property）
- 实例属性（Instance Property）:只能通过实例去访问
- *存储实例属性（Stored Intance Property）存储在实例的内存中，每个实例都有一份
- *计算实例属性（Computed Intance Property）
- 类型属性（Type Property）:只能通过类型去访问
- *存储类型属性（Stored Type Property）整个程序运中，就只有一份内存（类似全局变量）
- *计算类型属性（Computed Type Property）
- 可以通过static定义(存储、计算)类型属性，如果是类，其计算属性也可以用关键字class
struct Car {
static var count :Int = 0
var wheels :Int
init(wheels:Int) {
self.wheels = wheels
Car.count += 1
}
}
var car1 = Car.init(wheels: 4)
var car2 = Car.init(wheels: 2)
var car3 = Car.init(wheels: 3)
print(Car.count)//输出：3
//类 static定义存储属性 static/class定义计算属性
class Dinner {
static var count :Int = 0
var price :Int
class var totalPrice: Int {
set{
count = newValue / 5
}
get{
count * 5
}
}
init(price:Int) {
self.price = price
Dinner.count += 1
}
}
var dinner1 = Dinner.init(price: 5)
var dinner2 = Dinner.init(price: 10)
var dinner3 = Dinner.init(price: 20)
print(Dinner.count,Dinner.totalPrice)//输出：3 15
猜想：类型属性的内存是存在哪里呢？
var num1 = 10
class Car {
static var count = 0
}
Car.count = 11
var num = 11
内存地址是连续的 也就是说Car.count类似全局变量
为什么0xb赋值给%rax，而不是一个准确的地址类似全局变量呢？注意到汇编中有这样一个方法
打断点，si进去
注意到swift_once 猜想可能是调用了dispatch_once，继续往下走
到最后，到达这个页面 证实上面的猜想 即count通过GCD的dispatch_once初始化 且仅会初始化一次 又证实了类行属性初始化是线程安全的
类型属性重点:
- 不同于存储实例属性，存储类型属性必须设定初始值（因为没有init初始化器）
- 存储类型属性默认就是lazy，会在第一次使用的时候初始化
- 就算是多个线程同时访问，也只会初始化一次
- 存储类型属性可以是let（因为和实例初始化没有关系）
- 枚举类型也可以定义类型属性（存储类型属性、计算类型属性）
- 类型属性的应用场景：单例模式 保证该类仅会被初始化一次
public class FileManager {
public static let fileManager = FileManager()
private init(){
}
}
FileManager.fileManager
//var f1 = FileManager()//报错 'FileManager' initializer is inaccessible due to 'private' protection level
Swift学习日记10