swift语言中的结构与类

下面是一个带有class的例子。请注意，当名称更改时，两个变量引用的实例将如何更新。Bob现在是Sue，在任何Bob被引用的地方。

class SomeClass {
var name: String
init(name: String) {
self.name = name
}
}


var aClass = SomeClass(name: "Bob")
var bClass = aClass // aClass and bClass now reference the same instance!
bClass.name = "Sue"


println(aClass.name) // "Sue"
println(bClass.name) // "Sue"

现在使用struct，我们看到值被复制，每个变量保留自己的值集。当我们将名称设置为Sue时，aStruct中的Bob结构体不会被更改。

struct SomeStruct {
var name: String
init(name: String) {
self.name = name
}
}


var aStruct = SomeStruct(name: "Bob")
var bStruct = aStruct // aStruct and bStruct are two structs with the same value!
bStruct.name = "Sue"


println(aStruct.name) // "Bob"
println(bStruct.name) // "Sue"

因此，对于表示有状态的复杂实体，class非常棒。但对于仅仅是测量值或相关数据位的值，struct更有意义，这样你就可以轻松地复制它们并使用它们计算或修改值，而不用担心副作用。

struct是值类型。这意味着，如果你将结构的实例复制到另一个变量，它只是复制到变量。

值类型示例

struct Resolution {
var width = 2
var height = 3
}


let hd = Resolution(width: 1920, height: 1080)
var cinema = hd //assigning struct instance  to variable
println("Width of cinema instance is \(cinema.width)")//result is 1920
println("Width of hd instance is \(hd.width)")//result is 1920


cinema.width = 2048


println("Width of cinema instance is \(cinema.width)")//result is 2048
println("Width of hd instance is \(hd.width)")//result is 1920

类是引用类型。这意味着如果你将类的一个实例分配给一个变量，它将只保留参考实例和不是副本。

在本节中，你会看到:

< p >“让高清=决议(宽度:1920,身高:1080)var 这个例子声明了一个名为hd的常量，并设置了它 初始化为full的宽和高的Resolution实例 高清视频(1920像素宽，1080像素高)

然后声明一个名为cinema的变量，并将其设置为当前值 hd的值。因为决议是一种结构，是现有的副本 实例，并将此新副本分配给cinema。尽管 Hd和cinema现在有相同的宽和高，它们是两个 幕后完全不同的实例。

属性的width属性被修改为 用于数字电影放映的稍宽的2K标准(2048 像素宽和1080像素高):

电影。检查影院显示的width属性 它确实已经改变为2048:

< p > println(“现在电影(电影。宽度)像素宽”)/ / 的width属性现在是2048像素宽 原来的hd实例仍然有1920的旧值:

println ("hd is still (hd . width) pixels wide") //打印"hd . width " 仍然是1920像素宽"

当cinema被赋予hd的当前值时，值存储在hd中 复制到新的影院实例中。最终结果是2 完全独立的实例，恰好包含相同的实例 数值。因为它们是单独的实例，设置宽度

摘自:苹果公司的“快速编程语言。“iBooks。 https://itun.es/us/jEUH0.l < / p >

这是结构体和类之间最大的区别。复制结构，引用类。

通常(在大多数编程语言中)，对象是存储在堆上的数据块，然后对这些块的引用(通常是指针)包含用于访问这些数据块的name。这种机制允许通过复制对象引用(指针)的值来共享堆中的对象。对于基本数据类型(如integer)则不是这样，这是因为创建引用所需的内存几乎与对象相同(在本例中为整数值)。因此，在大对象的情况下，它们将作为值传递而不是作为引用。

Swift使用struct来提高String和Array对象的性能。

这是一本很好的读物

类和结构都可以做到:

• 定义属性来存储值
• 定义提供功能的方法
• 被扩展
• 遵守协议
• 定义初始化
• 定义下标以提供对其变量的访问

唯一的类可以做到:

• 继承
• 铸字
• 定义deinitialisers
• 允许多个引用进行引用计数。

下面是一个例子，它精确地显示了struct和class之间的区别。

struct Radio1{
var name:String
//    init(name:String) {
//        self.name = name
//    }
}


struct Car1{
var radio:Radio1?
var model:String


}


var i1 = Car1(radio: Radio1(name:"murphy"),model:"sedan")
var i2 = i1
//since car instance i1 is a struct and
//this car has every member as struct ,
//all values are copied into i2


i2.radio?.name //murphy
i2.radio = Radio1(name: "alpha")
i2.radio?.name //alpha


i1.radio?.name //murphy


//since Radio1 was struct ,
//values were copied and thus
// changing name  of instance of Radio1 in i2
//did not bring change in i1


class Radio2{
var name:String
init(name:String) {
self.name = name
}
}


struct Car2{
var radio:Radio2?
var model:String


}
var i3 = Car2(radio: Radio2(name:"murphy"),model:"sedan")
//var radioInstance = Radio2(name: "murphy")
//var i3 = Car2(radio: radioInstance,model:"sedan")


var i4 = i3
//since i3 is instance of struct
//everything is copied to i4 including reference of instance of Radio2
//because Radio2 is a class






i4.radio?.name //murphy
i4.radio?.name="alpha"
i4.radio?.name //alpha


i3.radio?.name //alpha


//since Radio2 was class,
//reference was copied and
//thus changing name of instance
//of Radio2 in i4 did  bring change in i3 too




//i4.radio?.name
//i4.radio = Radio2(name: "alpha")
//i4.radio?.name
//
//i3.radio?.name

以上答案都是正确的，我希望我的回答能帮助到那些不理解以上答案的人。

在Swift中有两种类型的对象

1. 结构体
2. 类

它们之间的主要区别是

• Struct是价值类型
• 类的类型是参考

例如这里的代码要理解得很好。

struct SomeStruct {
var a : Int;


init(_ a : Int) {
self.a = a
}
}


class SomeClass {
var a: Int;


init(_ a: Int) {
self.a = a
}


}
var x = 11


var someStruct1 = SomeStruct(x)
var someClass1 = SomeClass(x)


var someStruct2 = someStruct1
var someClass2 = someClass1


someClass1.a = 12
someClass2.a // answer is 12 because it is referencing to class 1     property a


someStruct1.a = 14
someStruct2.a // answer is 11 because it is just copying it not referencing it

这是主要的区别，但我们也有次要的区别。

类

1. 必须声明初始化式(构造函数)
2. 有deinitialisers
3. 可以从其他类继承吗

结构体

1. 它为你提供了自由初始化器，你不必声明初始化器，如果你声明了自由初始化器，它将被你声明的初始化器覆盖
2. 没有去初始化
3. 不能从其他结构继承

为了理解struct和class之间的区别，我们需要知道值类型和引用类型之间的主要区别。struct是值类型，这意味着对它们的每一次更改都只会修改该值，类是引用类型，引用类型中的每一次更改都将修改分配在内存或引用位置的值。例如:

让我们从一个类开始，这个类符合Equatable，只是为了能够比较实例，我们创建了一个名为__abc0的实例和另一个名为pointClassInstanceB的实例，我们将类a分配给类B，现在断言说它们是相同的…

class PointClass: Equatable {
var x: Double
var y: Double


init(x: Double, y: Double) {
self.x = x
self.y = y
}


static func == (lhs: PointClass, rhs: PointClass) -> Bool {
return lhs.x == rhs.x && lhs.y == rhs.y
}
}


var pointClassInstanceA = PointClass(x: 0, y: 0)
var pointClassInstanceB = pointClassInstanceA


assert(pointClassInstanceA==pointClassInstanceB)


pointClassInstanceB.x = 10
print(pointClassInstanceA.x)
//this prints 10

好的，这里发生了什么为什么如果我们改变了pointclassinstanceb的x值它也改变了pointClassInstanceA的x值?这展示了引用类型是如何工作的，当我们将实例A赋值为实例B的值，然后我们修改其中一个的X，它会改变两个X，因为它们共享相同的引用，而改变的是该引用的值。

让我们用结构体做同样的事情

struct PointStruct: Equatable {
var x: Double
var y: Double


init(x: Double, y: Double) {
self.x = x
self.y = y
}


static func == (lhs: PointStruct, rhs: PointStruct) -> Bool {
return lhs.x == rhs.x && lhs.y == rhs.y
}
}
var pointStructInstanceA = PointStruct(x: 0, y: 0)
var pointStructInstanceB = pointStructInstanceA


assert(pointStructInstanceA==pointStructInstanceB)
pointStructInstanceB.x = 100
print(pointStructInstanceA.x)
//this will print 0

我们的结构与我们的类基本相同，但现在你可以看到，当你打印pointStructInstanceA的x值时，它没有改变，这是因为值类型的工作方式不同，它们的一个实例上的每一个变化都是“独立的”，不会影响到另一个实例。