swift语言中的结构与类
来自苹果书 结构和类之间最重要的区别之一是，结构在代码中传递时总是被复制的，而类是通过引用传递的swift语言中的结构与类,swift,Swift,来自苹果书 结构和类之间最重要的区别之一是，结构在代码中传递时总是被复制的，而类是通过引用传递的 谁能帮我理解这意味着什么？对我来说，类和结构似乎是一样的。这里有一个类的例子。请注意，当名称更改时，两个变量引用的实例将如何更新Bob现在是Sue，无论Bob被引用到哪里 class SomeClass { var name: String init(name: String) { self.name = name } } var aClass = Some
谁能帮我理解这意味着什么？对我来说，类和结构似乎是一样的。这里有一个
类的例子。请注意，当名称更改时，两个变量引用的实例将如何更新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"
因此，对于表示有状态复杂实体而言，类
非常棒。但是对于仅仅是测量值或相关数据位的值，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
类是引用类型。这意味着，如果您将类的一个实例分配给一个变量，它将只保存对该实例的引用，而不保存副本。如果您在apple手册中进一步查看，您将看到以下部分：
“结构和枚举是值类型”
在本节中，您将看到：
"让 高清 = 决议(宽度: 1920, 高度: 1080) 变量
电影院 = hd本例声明一个名为hd的常量并设置它
到一个分辨率实例，该实例以完整的宽度和高度初始化
高清视频（1920像素宽，1080像素高）
然后声明一个名为cinema的变量，并将其设置为当前值
hd的值。因为分辨率是一个结构，所以它是现有
创建实例，并将此新副本分配给电影院
高清和电影现在有相同的宽度和高度，他们是两个
完全不同的幕后例子
接下来，将cinema的width属性修改为
略宽的2K标准，用于数字电影放映（2048年）
像素宽和1080像素高）：
电影院.宽度 = 2048检查电影院放映的宽度属性
事实上，它已经变为2048年：
普林顿(“电影现在很流行(电影院.宽度) 像素宽“) //
“打印”影院现在是2048像素宽，但是
原始hd实例仍然具有旧值1920：
普林顿("房屋署仍然(高清.宽度) 像素宽“) // 打印“高清
仍为1920像素宽”
当cinema被赋予hd的当前值时，存储在hd中的值
被复制到新的cinema实例中。最终结果是
完全独立的实例，恰好包含相同的
数值。因为它们是单独的实例，所以设置宽度
从电影院到2048年，不会影响高清存储的宽度。”
摘自：苹果公司《Swift编程语言》。iBooks。
这是结构和类之间最大的区别。复制结构并引用类。通常（在大多数编程语言中），对象是存储在堆上的数据块，然后是引用（通常是指针）对于这些块，包含用于访问这些数据块的名称。此机制允许通过复制其引用（指针）的值来共享堆中的对象。这不是整数等基本数据类型的情况，这是因为创建引用所需的内存几乎与对象相同（在本例中为整数值）。因此，对于大型对象，它们将作为值传递，而不是作为引用传递
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"
Swift使用struct来提高性能，即使是字符串和数组对象
类和结构都可以：
- 定义属性以存储值
- 定义提供功能的方法
- 延长
- 遵守协议
- 定义初始化器
- 定义下标以提供对其变量的访问
只有课堂才能做到：
- 继承权
- 类型铸造
- 定义去初始化器
- 允许对多个引用进行引用计数
下面是一个示例，它精确地显示了struct和class之间的差异
操场上编写代码的屏幕截图
以上答案是正确的，我希望我的答案能帮助那些不理解以上答案的人
斯威夫特有两种类型的物体
- 结构
- 阶级
它们之间的主要区别是
- 结构是值类型
- 类是参考类型
例如，这里的代码需要很好地理解
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
这是主要差异，但我们也有次差异
课程
必须声明初始化器（构造函数）
有去初始化器吗
可以从其他类继承
Struct
它有免费的初始化器为您，您不必声明初始化器，如果您这样做免费初始化器将被您声明的初始化器覆盖
不要去初始化
无法从其他结构继承
为了理解结构和类之间的区别，我们需要知道值类型和引用类型之间的主要区别
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
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
class MyClass {
var myName: String
init(myName: String){
self.myName = myName;
}
}
var myClassExistingName = MyClass(myName: "DILIP")
var myClassNewName = myClassExistingName
myClassNewName.myName = "John"
print("Current Name: ",myClassExistingName.myName)
print("Modified Name", myClassNewName.myName)
print("*************************")
struct myStruct {
var programmeType: String
init(programmeType: String){
self.programmeType = programmeType
}
}
var myStructExistingValue = myStruct(programmeType: "Animation")
var myStructNewValue = myStructExistingValue
myStructNewValue.programmeType = "Thriller"
print("myStructExistingValue: ", myStructExistingValue.programmeType)
print("myStructNewValue: ", myStructNewValue.programmeType)
Current Name: John
Modified Name John
*************************
myStructExistingValue: Animation
myStructNewValue: Thriller
1.structure is value type.
= > when we assign structure variable to other variable or pass as parameter to function, it creates separate/new copy => so that changes made on one variable does not reflect on another.[We can say like **call by value** concept]
Example :
struct DemoStruct
{
var value: String
init(inValue: String)
{
self.value = inValue
}
}
var aStruct = DemoStruct(inValue: "original")
var bStruct = aStruct // aStruct and bStruct are two structs with the same value! but references to diff location`enter code here`
bStruct.value = "modified"
print(aStruct.value) // "original"
print(bStruct.value) // "modified"
2.class is reference type.
= > when we assign structure variable to other variable or pass as parameter to function, it **does not** creates separate/new copy => so that changes made on one variable does not reflect on another.[We can say like **call by reference** concept]
Example:
class DemoClass
{
var value: String
init(inValue: String)
{
self.value = inValue
}
}
var aClass = DemoClass(inName: "original")
var bClass = aClass // aClass and bClass now reference the same instance!
bClass.value = "modified"
print(aClass.value) // "modified"
print(bClass.value) // "modified"