โครงสร้างกับคลาสในภาษาที่รวดเร็ว

จาก Apple book "หนึ่งในความแตกต่างที่สำคัญที่สุดระหว่างโครงสร้างและคลาสคือโครงสร้างจะถูกคัดลอกเสมอเมื่อมันถูกส่งผ่านไปในโค้ดของคุณ แต่คลาสจะถูกส่งผ่านโดยการอ้างอิง"

ทุกคนสามารถช่วยให้ฉันเข้าใจสิ่งที่หมายถึง? สำหรับฉันแล้วคลาสและโครงสร้างดูเหมือนจะเหมือนกัน

นี่คือตัวอย่าง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เป็นBobstruct ในaStructจะไม่เปลี่ยน

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เป็นเลิศ แต่สำหรับค่าที่เป็นเพียงการวัดหรือบิตของข้อมูลที่เกี่ยวข้อง a structจะเหมาะสมกว่าเพื่อให้คุณสามารถคัดลอกและคำนวณได้อย่างง่ายดายหรือแก้ไขค่าโดยไม่ต้องกลัวผลข้างเคียง

ทั้งคลาสและโครงสร้างสามารถทำได้:

• กำหนดคุณสมบัติเพื่อเก็บค่า
• กำหนดวิธีการเพื่อให้การทำงาน
• ถูกยืดออกไป
• สอดคล้องกับโปรโตคอล
• กำหนด intialisers
• กำหนด Subscripts เพื่อให้การเข้าถึงตัวแปรของพวกเขา

ชั้นเรียนเท่านั้นที่สามารถทำได้:

• มรดก
• ประเภทหล่อ
• กำหนด deinitialisers
• อนุญาตการนับการอ้างอิงสำหรับการอ้างอิงหลายรายการ

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

ชั้นเรียนเป็นประเภทอ้างอิง ก็หมายความว่าถ้าคุณกำหนดอินสแตนซ์ของระดับชั้นให้กับตัวแปรก็จะถือเพียงการอ้างอิงอินสแตนซ์และไม่คัดลอก

คำตอบข้างต้นนั้นถูกต้องฉันหวังว่าคำตอบของฉันจะช่วยคนที่ไม่เข้าใจคำตอบข้างต้น

Well in Swift มีวัตถุสองประเภท

1. โครงสร้าง
2. ชั้น

ความแตกต่างที่สำคัญระหว่างพวกเขาคือ

• โครงสร้างเป็นประเภทค่า
• 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

นี่คือความแตกต่างหลัก แต่เราก็มีความแตกต่างย่อยเช่นกัน

ชั้น

1. ต้องประกาศผู้เริ่มต้น (ผู้สร้าง)
2. มีผู้ชำนาญการ deinitialisers
3. สามารถสืบทอดจากคลาสอื่น ๆ

โครงสร้าง

1. มันมีผู้เริ่มต้นฟรีสำหรับคุณคุณไม่ต้องประกาศผู้เริ่มต้นถ้าคุณทำผู้เริ่มต้นฟรีจะถูกเขียนทับโดยผู้ประกาศต้นของคุณ
2. ไม่ต้องมีเครื่องมือกำจัดกลิ่น
3. ไม่สามารถสืบทอดจาก struct อื่น ๆ

คำถามนี้ดูเหมือนจะซ้ำกัน แต่ไม่คำนึงถึงสิ่งต่อไปนี้จะตอบกรณีการใช้งานส่วนใหญ่:

1. หนึ่งในความแตกต่างที่สำคัญที่สุดระหว่างโครงสร้างและคลาสคือโครงสร้างเป็นประเภทค่าและจะถูกคัดลอกเสมอเมื่อมีการส่งผ่านไปยังโค้ดของคุณและคลาสเป็นประเภทอ้างอิงและถูกส่งผ่านโดยการอ้างอิง

2. นอกจากนี้คลาสมีการสืบทอดซึ่งอนุญาตให้หนึ่งคลาสเพื่อสืบทอดลักษณะของอีกคลาส

3. คุณสมบัติของโครงสร้างจะถูกเก็บไว้ในอินสแตนซ์สแต็คและคลาสจะถูกเก็บไว้ในฮีปดังนั้นบางครั้งสแต็กจะเร็วกว่าคลาสมาก

4. Struct รับค่าเริ่มต้นเริ่มต้นโดยอัตโนมัติในชั้นเรียนเราต้องเริ่มต้น

5. Struct คือ thread safe หรือ singleton ณ จุดใดก็ได้

และเพื่อสรุปความแตกต่างระหว่าง structs และคลาสคุณจำเป็นต้องเข้าใจความแตกต่างระหว่างค่าและประเภทการอ้างอิง

1. เมื่อคุณทำสำเนาชนิดของค่ามันจะคัดลอกข้อมูลทั้งหมดจากสิ่งที่คุณกำลังคัดลอกไปยังตัวแปรใหม่ พวกเขาเป็น 2 สิ่งที่แยกจากกันและการเปลี่ยนแปลงอย่างใดอย่างหนึ่งไม่ได้ส่งผลกระทบต่ออีก
2. เมื่อคุณทำสำเนาชนิดอ้างอิงตัวแปรใหม่อ้างถึงตำแหน่งหน่วยความจำเดียวกับสิ่งที่คุณกำลังคัดลอก ซึ่งหมายความว่าการเปลี่ยนจะเปลี่ยนอีกอันเนื่องจากทั้งคู่อ้างถึงตำแหน่งหน่วยความจำเดียวกัน โค้ดตัวอย่างด้านล่างสามารถนำมาเป็นข้อมูลอ้างอิงได้

// sampleplayground.playground

  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

หากคุณดูไกลออกไปในคู่มือแอปเปิ้ลคุณจะเห็นส่วนนี้:“ โครงสร้างและการแจกแจงคือประเภทของมูลค่า”

ในส่วนนี้คุณจะเห็นสิ่งนี้:

“ ให้ hd = ความละเอียด (ความกว้าง: 1920, ความสูง: 1080) var cinema = hd ตัวอย่างนี้ประกาศค่าคงที่ที่เรียกว่า hd และตั้งค่าเป็นความละเอียด อินสแตนซ์เริ่มต้นด้วยความกว้างและความสูงของวิดีโอ Full HD (ความกว้าง 1920 พิกเซลสูง 1080 พิกเซล)

จากนั้นจะประกาศตัวแปรที่เรียกว่า cinema และตั้งค่าเป็นค่า hd ปัจจุบัน เนื่องจากความละเอียดเป็นโครงสร้างจึงมีการสร้างสำเนาของอินสแตนซ์ที่มีอยู่และสำเนาใหม่นี้ถูกกำหนดให้กับโรงภาพยนตร์ แม้ว่าตอนนี้ HD และโรงภาพยนตร์จะมีความกว้างและความสูงเท่ากัน แต่ก็เป็นสองกรณีที่แตกต่างกันโดยสิ้นเชิงเบื้องหลัง

ถัดไปคุณสมบัติความกว้างของโรงภาพยนตร์ได้รับการแก้ไขให้เป็นความกว้างของมาตรฐาน 2K ที่กว้างขึ้นเล็กน้อยที่ใช้สำหรับการฉายภาพยนตร์ในโรงภาพยนตร์ดิจิตอล (กว้าง 2048 พิกเซลและสูง 1080 พิกเซล):

cinema. width = 2048 การตรวจสอบคุณสมบัติความกว้างของโรงภาพยนตร์แสดงให้เห็นว่ามันได้เปลี่ยนเป็น 2048:

println ("โรงภาพยนตร์อยู่ในขณะนี้ (ความกว้างโรงภาพยนตร์) พิกเซลกว้าง") // โรงพิมพ์ "ตอนนี้มีความกว้าง 2048 พิกเซลอย่างไรก็ตามคุณสมบัติความกว้างของอินสแตนซ์ hd ดั้งเดิมยังคงเดิม มูลค่า 1920:

println ("hd ยังกว้าง (กว้าง hd.) พิกเซลกว้าง") // พิมพ์ "hd ยังคงกว้าง 1920 พิกเซล"

เมื่อโรงภาพยนตร์ได้รับค่าปัจจุบันเป็น hd ค่าที่จัดเก็บในรูปแบบ HD จะถูกคัดลอกไปยังอินสแตนซ์โรงภาพยนตร์ใหม่ ผลลัพธ์ที่ได้คือสองอินสแตนซ์ที่แยกจากกันอย่างสมบูรณ์ซึ่งเพิ่งเกิดขึ้นเพื่อให้มีค่าตัวเลขที่เหมือนกัน เนื่องจากเป็นกรณีที่แยกกันการตั้งค่าความกว้างของโรงภาพยนตร์เป็น 2048 จึงไม่ส่งผลกระทบต่อความกว้างที่เก็บในรูปแบบ HD”

ข้อความที่ตัดตอนมาจาก: Apple Inc. “ ภาษาการเขียนโปรแกรม Swift” iBooks https://itun.es/us/jEUH0.l

นี่คือความแตกต่างที่ใหญ่ที่สุดระหว่าง structs และคลาส Structs จะถูกคัดลอกและมีการอ้างอิงคลาส

โดยปกติ (ในภาษาการเขียนโปรแกรมส่วนใหญ่) วัตถุคือบล็อกของข้อมูลที่เก็บไว้ในกองแล้วอ้างอิง (ปกติตัวชี้) ไปยังบล็อกเหล่านี้มีการnameใช้เพื่อเข้าถึงบล็อกข้อมูลเหล่านี้ กลไกนี้อนุญาตให้ใช้วัตถุร่วมกันในกองโดยคัดลอกค่าของการอ้างอิงของพวกเขา (ตัวชี้) นี่ไม่ใช่กรณีของชนิดข้อมูลพื้นฐานเช่นจำนวนเต็มและนั่นเป็นเพราะหน่วยความจำที่จำเป็นในการสร้างการอ้างอิงเกือบจะเหมือนกับวัตถุ (ในกรณีนี้เป็นจำนวนเต็มค่า) ดังนั้นพวกเขาจะถูกส่งผ่านเป็นค่าไม่อ้างอิงในกรณีของวัตถุขนาดใหญ่

Swift ใช้โครงสร้างเพื่อปรับปรุงประสิทธิภาพแม้กับวัตถุ String และ Array

อ่านดีจริงๆที่นี่

เพื่อที่จะเข้าใจความแตกต่างระหว่างโครงสร้างและคลาสเราจำเป็นต้องทราบความแตกต่างที่สำคัญระหว่างค่าและประเภทอ้างอิง Structs เป็นประเภทค่าและนั่นหมายความว่าการเปลี่ยนแปลงทุกอย่างจะเปลี่ยนค่านั้น Classes เป็นประเภทการอ้างอิงและการเปลี่ยนแปลงในประเภทการอ้างอิงทุกครั้งจะปรับเปลี่ยนค่าที่จัดสรรในหน่วยความจำหรือการอ้างอิงนั้น ตัวอย่างเช่น:

เรามาเริ่มด้วยคลาสคลาสนี้สอดคล้องกับ Equatable เพียงเพื่อเปรียบเทียบอินสแตนซ์เราสร้างอินสแตนซ์ที่เรียกว่าpointClassInstanceAและอื่น ๆ ที่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

ตกลงเกิดอะไรขึ้นที่นี่ทำไมถ้าเราเพิ่งเปลี่ยนค่า x ของ pointsClassInstanceB มันก็เปลี่ยนค่า x ของ pointClassInstanceA? ทีนี้นี่แสดงให้เห็นว่าประเภทการอ้างอิงทำงานอย่างไรเมื่อเรากำหนดอินสแตนซ์ 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

เรามีโครงสร้างแบบเดียวกับคลาสของเรา แต่ตอนนี้คุณสามารถเห็นได้ว่าเมื่อคุณพิมพ์ค่า x ของ pointStructInstance ในกรณีนี้มันไม่เปลี่ยนแปลงและนี่เป็นเพราะประเภทของค่าทำงานแตกต่างกันและการเปลี่ยนแปลงทุกอย่างในอินสแตนซ์ของพวกเขาจะเป็น " อิสระ "และจะไม่ส่งผลกระทบอื่น ๆ

Swift แนะนำให้ใช้ประเภทของค่ามากขึ้นและคุณสามารถบอกได้ว่าไลบรารีของพวกเขานั้นขึ้นอยู่กับโครงสร้างเพื่อหลีกเลี่ยงปัญหาที่ชนิดของการอ้างอิงนำมาเช่นการปรับเปลี่ยนค่าโดยไม่ตั้งใจเป็นต้นโครงสร้างเป็นวิธีที่จะดำเนินการต่อไปอย่างรวดเร็ว หวังว่ามันจะช่วย

นี่คือตัวอย่างที่แสดงความแตกต่างระหว่างโครงสร้างและคลาสอย่างแม่นยำ

สกรีนช็อตของโค้ดที่เขียนในสนามเด็กเล่น

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

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"

ประเภทสวิฟท์

Value type เป็นประเภทที่ค่าถูกคัดลอกเมื่อถูกกำหนดให้กับตัวแปรหรือค่าคงที่หรือเมื่อถูกส่งไปยังฟังก์ชัน

Reference types จะไม่ถูกคัดลอกเมื่อถูกกำหนดให้กับตัวแปรหรือค่าคงที่หรือเมื่อพวกมันถูกส่งไปยังฟังก์ชัน

ราคาประเภท :
Struct, Enum, Tuple
struct String, struct Array( Set, Dictionary)

• เมื่อคุณกำหนดหรือผ่าน value typeใหม่สำเนาของข้อมูลจะถูกสร้างขึ้น ที่จริงแล้วกลไกcopy on write- COWใช้กับการปรับให้เหมาะสมตัวอย่างเช่นการคัดลอกจะถูกสร้างขึ้นเมื่อวัตถุถูกปรับเปลี่ยน
• เมื่อคุณปรับเปลี่ยนเช่นมันจะมีเพียงในท้องถิ่นผล
• ใช้หน่วยความจำสแต็ก

ประเภทอ้างอิง :
Class,Function

• เมื่อคุณกำหนดหรือส่งreference typeการอ้างอิงใหม่ไปยังอินสแตนซ์ดั้งเดิมจะถูกสร้างขึ้น (ที่อยู่ของอินสแตนซ์จะถูกคัดลอก)
• เมื่อคุณแก้ไขอินสแตนซ์มันจะมีผลกระทบระดับโลกเพราะอินสแตนซ์นั้นถูกแชร์และเข้าถึงได้โดยการอ้างอิงใด ๆ ที่ชี้ไปที่มัน
• กองหน่วยความจำถูกนำมาใช้

Value typeขอแนะนำให้ใช้ตามค่าเริ่มต้น ข้อได้เปรียบที่ใหญ่ที่สุดValue typeคือพวกเขามักจะเป็นthread safe

Reference type ข้อดี:

• พวกเขาสามารถสืบทอด
• deinit() สามารถใช้ได้,
• เปรียบเทียบกรณีโดยการอ้างอิง===,
• Objective-Cการทำงานร่วมกันเพราะValue Typeถูกนำมาใช้ในสวิฟท์

[เพิ่มเติมเกี่ยวกับความไม่แน่นอน]
เลือกระหว่างโครงสร้างและการเรียน
ประเภท
ชั้นเรียนและโครงสร้าง

Alreday มีจำนวนมากที่เขียนเกี่ยวกับเรื่องนี้ฉันต้องการที่จะเพิ่มการเปรียบเทียบที่นั่น หวังว่าคุณจะไม่สงสัยในสิ่งนี้หลังจากนี้: Bottom line: คลาสจะถูกส่งผ่านโดยการอ้างอิงในขณะที่ structs ถูกส่งผ่านตามค่า

สมมติว่าคุณกำลังแบ่งปันแผ่นงาน Google เอกสารกับเพื่อนของคุณ ตอนนี้ถ้าเขาเปลี่ยนแปลงอะไรในนั้นคุณจะเห็นว่าการเปลี่ยนแปลงใน Google เอกสารของคุณหมายความว่าสำเนาของคุณจะได้รับผลกระทบด้วย นั่นเป็นเพียง " ส่งผ่านโดยอ้างอิง "

แต่สมมติว่าหากคุณมี. XLS fie บันทึกไว้ในเครื่องของคุณ คุณให้ไฟล์นั้นให้กับเพื่อนของคุณ ตอนนี้ถ้าเขาทำการเปลี่ยนแปลงใด ๆ ในไฟล์นั้นไฟล์ของคุณจะไม่ถูกทำให้ยุ่งเหยิง / มีผลเพราะคุณมีสำเนาของคุณเอง นั่นคือ " ผ่านค่า " โดยทั่วไป คุณมีโปรแกรมง่าย ๆ หลายโปรแกรมอยู่แล้วเพื่อตรวจสอบความคล้ายคลึงนี้ในสนามเด็กเล่นที่รวดเร็ว